//
// File generated by /home/root/bin/rootcint at Mon Oct 11 17:11:18 2021

// Do NOT change. Changes will be lost next time file is generated
//

#define R__DICTIONARY_FILENAME builddIlinuxx8664gccdIRAT_Dict
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "RAT_Dict.h"

#include "TCollectionProxyInfo.h"
#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"

// Direct notice to TROOT of the dictionary's loading.
namespace {
   static struct DictInit {
      DictInit() {
         ROOT::RegisterModule();
      }
   } __TheDictionaryInitializer;
}

// START OF SHADOWS

namespace ROOTShadow {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< unsigned int, ::RAT::DS::BitMask > pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR;
      #else
      class pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR  {
         public:
         //friend XX;
         unsigned int first; //
         ::RAT::DS::BitMask second; //
      };
      #endif

      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::DisplacementVector3D< ::ROOT::Math::Cartesian3D< double >, ::ROOT::Math::DefaultCoordinateSystemTag > DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
      #else
      class DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         typedef ::ROOT::Math::Cartesian3D<double> CoordinateType;
         typedef ::ROOT::Math::DefaultCoordinateSystemTag CoordinateSystemTag;
         ::ROOT::Math::Cartesian3D< double > fCoordinates; //internal coordinate system
      };
      #endif
      } } 
      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::Cartesian3D< float > Cartesian3DlEfloatgR;
      #else
      class Cartesian3DlEfloatgR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         float fX; //x coordinate
         float fY; //y coordinate
         float fZ; //z coordinate
      };
      #endif
      } } 
      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::DisplacementVector3D< ::ROOT::Math::Cartesian3D< float >, ::ROOT::Math::DefaultCoordinateSystemTag > DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
      #else
      class DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         typedef ::ROOT::Math::Cartesian3D<float> CoordinateType;
         typedef ::ROOT::Math::DefaultCoordinateSystemTag CoordinateSystemTag;
         ::ROOT::Math::Cartesian3D< float > fCoordinates; //internal coordinate system
      };
      #endif
      } } 
      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::DisplacementVector3D< ::ROOT::Math::Polar3D< double >, ::ROOT::Math::DefaultCoordinateSystemTag > DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
      #else
      class DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         typedef ::ROOT::Math::Polar3D<double> CoordinateType;
         typedef ::ROOT::Math::DefaultCoordinateSystemTag CoordinateSystemTag;
         ::ROOT::Math::Polar3D< double > fCoordinates; //internal coordinate system
      };
      #endif
      } } 
      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::Polar3D< float > Polar3DlEfloatgR;
      #else
      class Polar3DlEfloatgR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         float fR; //
         float fTheta; //
         float fPhi; //
      };
      #endif
      } } 
      namespace ROOT {
         namespace Math {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::ROOT::Math::DisplacementVector3D< ::ROOT::Math::Polar3D< float >, ::ROOT::Math::DefaultCoordinateSystemTag > DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
      #else
      class DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR  {
         public:
         //friend XX;
         typedef void* (*Scalar)() ;
         typedef ::ROOT::Math::Polar3D<float> CoordinateType;
         typedef ::ROOT::Math::DefaultCoordinateSystemTag CoordinateSystemTag;
         ::ROOT::Math::Polar3D< float > fCoordinates; //internal coordinate system
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::FitClassifierCollection< ::RAT::DS::FitResult > FitClassifierCollectionlERATcLcLDScLcLFitResultgR;
      #else
      class FitClassifierCollectionlERATcLcLDScLcLFitResultgR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::RAT::DS::FitClassifierCollection< ::RAT::DS::FitResult >::NoResultError NoResultError;
         #else
         class NoResultError  :  public ::RAT::DS::DataNotFound {
            public:
            //friend XX;
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~FitClassifierCollectionlERATcLcLDScLcLFitResultgR() throw() {};
         map< ::string, ::RAT::DS::FitResult > results; ///< map results, indexed by name
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::FitClassifierCollection< ::RAT::DS::ClassifierResult > FitClassifierCollectionlERATcLcLDScLcLClassifierResultgR;
      #else
      class FitClassifierCollectionlERATcLcLDScLcLClassifierResultgR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::RAT::DS::FitClassifierCollection< ::RAT::DS::ClassifierResult >::NoResultError NoResultError;
         #else
         class NoResultError  :  public ::RAT::DS::DataNotFound {
            public:
            //friend XX;
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~FitClassifierCollectionlERATcLcLDScLcLClassifierResultgR() throw() {};
         map< ::string, ::RAT::DS::ClassifierResult > results; ///< map results, indexed by name
      };
      #endif
      } } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::Log Log;
      #else
      class Log  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::RAT::Log::Level Level;
         #else
         enum Level  {
         };
         #endif

      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::BitManip BitManip;
      #else
      class BitManip  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~BitManip() throw() {};
      };
      #endif
      } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::PMT< Double32_t > PMTlEDouble32_tgR;
      #else
      class PMTlEDouble32_tgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PMTlEDouble32_tgR() throw() {};
         unsigned int id; ///< PMT ID, i.e. logical channel number
         double qhs; ///< Charge: high gain, short integration time
         double qhl; ///< Charge: high gain, long integration time
         double qlx; ///< Charge: low gain charge
         double time; ///< Hit time
         unsigned short cellID; ///< Cell number in electronics
         char chanFlags; ///< Electronics errors/settings
         bool isCrossTalk; ///< True if this hit is cause by crosstalk
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::PMT< unsigned short > PMTlEunsignedsPshortgR;
      #else
      class PMTlEunsignedsPshortgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PMTlEunsignedsPshortgR() throw() {};
         unsigned int id; ///< PMT ID, i.e. logical channel number
         unsigned short qhs; ///< Charge: high gain, short integration time
         unsigned short qhl; ///< Charge: high gain, long integration time
         unsigned short qlx; ///< Charge: low gain charge
         unsigned short time; ///< Hit time
         unsigned short cellID; ///< Cell number in electronics
         char chanFlags; ///< Electronics errors/settings
         bool isCrossTalk; ///< True if this hit is cause by crosstalk
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::PMTSet< ::RAT::DS::PMT< unsigned short >  > PMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR;
      #else
      class PMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR() throw() {};
         vector< ::RAT::DS::PMT< unsigned short >  > normal; ///< Collection of normal PMTs
         vector< ::RAT::DS::PMT< unsigned short >  > inward; ///< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files
         vector< ::RAT::DS::PMT< unsigned short >  > owl; ///< Collection of OWL PMTs
         vector< ::RAT::DS::PMT< unsigned short >  > lowGain; ///< Collection of Low Gain PMTs
         vector< ::RAT::DS::PMT< unsigned short >  > butt; ///< Collection of BUTT PMTs (don't exist in SNO+)
         vector< ::RAT::DS::PMT< unsigned short >  > neck; ///< Collection of neck PMTs
         vector< ::RAT::DS::PMT< unsigned short >  > fecd; ///< Collection of FECD PMTs (really daq channels)
         vector< ::RAT::DS::PMT< unsigned short >  > spare; ///< Collection of spare PMTs (really daq channels)
         vector< ::RAT::DS::PMT< unsigned short >  > hqe; ///< Collection of HQE PMTs
         vector< ::RAT::DS::PMT< unsigned short >  > invalid; ///< Collection of invalid PMTs (really daq channels)
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::PMTSet< ::RAT::DS::PMTCal > PMTSetlERATcLcLDScLcLPMTCalgR;
      #else
      class PMTSetlERATcLcLDScLcLPMTCalgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PMTSetlERATcLcLDScLcLPMTCalgR() throw() {};
         vector< ::RAT::DS::PMTCal > normal; ///< Collection of normal PMTs
         vector< ::RAT::DS::PMTCal > inward; ///< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files
         vector< ::RAT::DS::PMTCal > owl; ///< Collection of OWL PMTs
         vector< ::RAT::DS::PMTCal > lowGain; ///< Collection of Low Gain PMTs
         vector< ::RAT::DS::PMTCal > butt; ///< Collection of BUTT PMTs (don't exist in SNO+)
         vector< ::RAT::DS::PMTCal > neck; ///< Collection of neck PMTs
         vector< ::RAT::DS::PMTCal > fecd; ///< Collection of FECD PMTs (really daq channels)
         vector< ::RAT::DS::PMTCal > spare; ///< Collection of spare PMTs (really daq channels)
         vector< ::RAT::DS::PMTCal > hqe; ///< Collection of HQE PMTs
         vector< ::RAT::DS::PMTCal > invalid; ///< Collection of invalid PMTs (really daq channels)
      };
      #endif
      } } 
      namespace RAT {
         namespace DS {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DS::PMTSet< ::RAT::DS::MCHit > PMTSetlERATcLcLDScLcLMCHitgR;
      #else
      class PMTSetlERATcLcLDScLcLMCHitgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PMTSetlERATcLcLDScLcLMCHitgR() throw() {};
         vector< ::RAT::DS::MCHit > normal; ///< Collection of normal PMTs
         vector< ::RAT::DS::MCHit > inward; ///< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files
         vector< ::RAT::DS::MCHit > owl; ///< Collection of OWL PMTs
         vector< ::RAT::DS::MCHit > lowGain; ///< Collection of Low Gain PMTs
         vector< ::RAT::DS::MCHit > butt; ///< Collection of BUTT PMTs (don't exist in SNO+)
         vector< ::RAT::DS::MCHit > neck; ///< Collection of neck PMTs
         vector< ::RAT::DS::MCHit > fecd; ///< Collection of FECD PMTs (really daq channels)
         vector< ::RAT::DS::MCHit > spare; ///< Collection of spare PMTs (really daq channels)
         vector< ::RAT::DS::MCHit > hqe; ///< Collection of HQE PMTs
         vector< ::RAT::DS::MCHit > invalid; ///< Collection of invalid PMTs (really daq channels)
      };
      #endif
      } } 
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< unsigned int, ::RAT::DS::PMTSet< ::RAT::DS::PMTCal >  > pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR;
      #else
      class pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR  {
         public:
         //friend XX;
         unsigned int first; //
         ::RAT::DS::PMTSet< ::RAT::DS::PMTCal > second; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< unsigned int, ::RAT::DS::FitClassifierCollection< ::RAT::DS::FitResult >  > pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR;
      #else
      class pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR  {
         public:
         //friend XX;
         unsigned int first; //
         ::RAT::DS::FitClassifierCollection< ::RAT::DS::FitResult > second; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< unsigned int, ::RAT::DS::FitClassifierCollection< ::RAT::DS::ClassifierResult >  > pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR;
      #else
      class pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR  {
         public:
         //friend XX;
         unsigned int first; //
         ::RAT::DS::FitClassifierCollection< ::RAT::DS::ClassifierResult > second; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< ::string, ::string > pairlEstringcOstringgR;
      #else
      class pairlEstringcOstringgR  {
         public:
         //friend XX;
         string first; //
         string second; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef pair< unsigned int, ::RAT::DS::SOCPMT > pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR;
      #else
      class pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR  {
         public:
         //friend XX;
         unsigned int first; //
         ::RAT::DS::SOCPMT second; //
      };
      #endif

      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DBTable DBTable;
      #else
      class DBTable  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::RAT::DBTable::FieldType FieldType;
         #else
         enum FieldType  {
         };
         #endif

         string tblname; //*< Name of table */
         string index; //*< Index of table */
         int run_begin; //*< First run in which this table is valid */
         int run_end; //*< Last run in which this table is valid */
         int pass_number; //*< Pass number of this table */
         unsigned long bytes; //*< Number of bytes required by values.  Approximate */
         ::json::Value table; //
         ::stlplus::hash< ::string, ::RAT::DBTable::FieldType, ::RAT::pyhash, ::equal_to< ::string >  > arrayTypeCache; //
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DBLink DBLink;
      #else
      class DBLink  {
         public:
         //friend XX;
         ::RAT::DB* db; //
         string tblname; //
         string index; //
         unsigned int currentRun; //
         bool loadFromDefaultPlane; //
         int pass; //
         bool validVersion; //
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::PgSQLBackend PgSQLBackend;
      #else
      class PgSQLBackend  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~PgSQLBackend() throw() {};
         ::pg_conn* pg_conn_; //
         ::pg_result* pg_res_; //
         ::pgNotify* pg_notify_; //
         string server_url_; //
         string conn_options_; //
         unsigned int num_reconn_; //
         unsigned int num_sec_wait_; //
         bool bor_done_; //
         bool bor_warn_given_; //
         string ratdb_tag_; //
         string ratdb_header_tbl_; //
      };
      #endif
      } 
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::simple_ptr_nocopy< ::RAT::DBTable > simple_ptr_nocopylERATcLcLDBTablegR;
      #else
      class simple_ptr_nocopylERATcLcLDBTablegR  {
         public:
         //friend XX;
         typedef ::RAT::DBTable value_type;
         typedef ::RAT::DBTable& reference;
         typedef ::RAT::DBTable& const_reference;
         ::RAT::DBTable* m_pointer; //
         unsigned int* m_count; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::simple_ptr_nocopy< ::RAT::DBLink > simple_ptr_nocopylERATcLcLDBLinkgR;
      #else
      class simple_ptr_nocopylERATcLcLDBLinkgR  {
         public:
         //friend XX;
         typedef ::RAT::DBLink value_type;
         typedef ::RAT::DBLink& reference;
         typedef ::RAT::DBLink& const_reference;
         ::RAT::DBLink* m_pointer; //
         unsigned int* m_count; //
      };
      #endif

      namespace RAT {
         namespace DU {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DU::ReconCorrector ReconCorrector;
      #else
      class ReconCorrector  {
         public:
         //friend XX;
         bool fInitDone; //
         vector< double > fMeVValuesOld1; //
         vector< double > fMeVValuesNew1; //
         vector< double > fPredictedNphotonsOld1; //
         vector< double > fPredictedNphotonsNew1; //
         vector< double > fMeVValuesOld2; //
         vector< double > fMeVValuesNew2; //
         vector< double > fPredictedNphotonsOld2; //
         vector< double > fPredictedNphotonsNew2; //
      };
      #endif
      } } 
      namespace RAT {
         namespace DU {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DU::ReconCalibrator ReconCalibrator;
      #else
      class ReconCalibrator  {
         public:
         //friend XX;
         bool fInitDone; //
         double fZoffsetAV; //
         double fRadiusAVOuterSqr; //
         vector< double > fCoefficientsData1; //
         vector< double > fCoefficientsSim1; //
         vector< double > fCoefficientsData2; //
         vector< double > fCoefficientsSim2; //
         vector< double > fCoefficientsExtData2; //
         vector< double > fCoefficientsExtSim2; //
      };
      #endif
      } } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::FitterPMT FitterPMT;
      #else
      class FitterPMT  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~FitterPMT() throw() {};
         int fID; ///< The PMT channel number/id or lcn
         int fCCCC; //CCCC ( Crate Card Channel Cell number )
         double fTime; ///< The hit time or centroid
         double fTimeError; ///< Error associated with the hit time or centroid
         double fQHL; ///< The hit QHL charge
         double fQHLError; ///< Error associated with the QHL charge
         double fQHS; ///< The hit QHS charge
         double fQHSError; ///< Error associated with the QHS charge
         double fQLX; ///< The hit QLX charge
         double fQLXError; ///< Error associated with the QLX charge
         ::RAT::DS::BitMask fStatus; ///< Status flags for the various calibrations
         bool fCrossTalkFlag; ///< Crosstalk flag for each pmt hit
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DBCommandLoader DBCommandLoader;
      #else
      class DBCommandLoader  {
         public:
         //friend XX;
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DBTextLoader DBTextLoader;
      #else
      class DBTextLoader  {
         public:
         //friend XX;
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::DBJsonLoader DBJsonLoader;
      #else
      class DBJsonLoader  {
         public:
         //friend XX;
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::HTTPDownloader HTTPDownloader;
      #else
      class HTTPDownloader  {
         public:
         //friend XX;
         void* handle; //
         bool noproxy_set; //
         ::basic_ostringstream< char, ::char_traits< char >, allocator< char >  > contents; //
      };
      #endif
      } 
      namespace RAT {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::MetaInformation MetaInformation;
      #else
      class MetaInformation  {
         public:
         //friend XX;
         ::RAT::DS::Meta fMeta; //The actual meta information
      };
      #endif
      } 
      namespace RAT {
         namespace LP {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::LP::LightPath LightPath;
      #else
      class LightPath  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::RAT::LP::LightPath::RegionType RegionType;
         #else
         enum RegionType  {
         };
         #endif

         double fEnergy; //
         vector< ::RAT::DU::Point3D > fPoint; //
         vector< ::TVector3 > fDirection; //
         vector< RegionType > fRegionType; //
         string fFitter; //
      };
      #endif
      } } 
      namespace RAT {
         namespace LP {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::LP::LightPathFitter LightPathFitter;
      #else
      class LightPathFitter  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~LightPathFitter() throw() {};
      };
      #endif
      } } 
      namespace RAT {
         namespace LP {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::LP::LightPathStraightFitter LightPathStraightFitter;
      #else
      class LightPathStraightFitter  :  public ::RAT::LP::LightPathFitter {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~LightPathStraightFitter() throw() {};
      };
      #endif
      } } 
      namespace RAT {
         namespace LP {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::LP::LightPathStraightScint LightPathStraightScint;
      #else
      class LightPathStraightScint  :  public ::RAT::LP::LightPathFitter {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~LightPathStraightScint() throw() {};
      };
      #endif
      } } 
      namespace RAT {
         namespace LP {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::RAT::LP::LightPathStraightScintWater LightPathStraightScintWater;
      #else
      class LightPathStraightScintWater  :  public ::RAT::LP::LightPathFitter {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~LightPathStraightScintWater() throw() {};
      };
      #endif
      } } 
   } // of namespace Shadow
} // of namespace ROOTShadow
// END OF SHADOWS

namespace RAT {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void RAT_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("RAT", 0 /*version*/, "include/RAT/LightPathStraightScintWater.hh", 19,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &RAT_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void RAT_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOTDict {
   void RATcLcLDScLcLBitMask_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLBitMask(void *p = 0);
   static void *newArray_RATcLcLDScLcLBitMask(Long_t size, void *p);
   static void delete_RATcLcLDScLcLBitMask(void *p);
   static void deleteArray_RATcLcLDScLcLBitMask(void *p);
   static void destruct_RATcLcLDScLcLBitMask(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::BitMask*)
   {
      ::RAT::DS::BitMask *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::BitMask >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::BitMask", ::RAT::DS::BitMask::Class_Version(), "include/RAT/DS/BitMask.hh", 37,
                  typeid(::RAT::DS::BitMask), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::BitMask::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::BitMask) );
      instance.SetNew(&new_RATcLcLDScLcLBitMask);
      instance.SetNewArray(&newArray_RATcLcLDScLcLBitMask);
      instance.SetDelete(&delete_RATcLcLDScLcLBitMask);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLBitMask);
      instance.SetDestructor(&destruct_RATcLcLDScLcLBitMask);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::BitMask*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::BitMask*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLCalib_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLCalib(void *p = 0);
   static void *newArray_RATcLcLDScLcLCalib(Long_t size, void *p);
   static void delete_RATcLcLDScLcLCalib(void *p);
   static void deleteArray_RATcLcLDScLcLCalib(void *p);
   static void destruct_RATcLcLDScLcLCalib(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Calib*)
   {
      ::RAT::DS::Calib *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Calib >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::Calib", ::RAT::DS::Calib::Class_Version(), "include/RAT/DS/Calib.hh", 28,
                  typeid(::RAT::DS::Calib), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::Calib::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::Calib) );
      instance.SetNew(&new_RATcLcLDScLcLCalib);
      instance.SetNewArray(&newArray_RATcLcLDScLcLCalib);
      instance.SetDelete(&delete_RATcLcLDScLcLCalib);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLCalib);
      instance.SetDestructor(&destruct_RATcLcLDScLcLCalib);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Calib*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::Calib*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::Calib*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void exception_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void exception_Dictionary();
   static void *new_exception(void *p = 0);
   static void *newArray_exception(Long_t size, void *p);
   static void delete_exception(void *p);
   static void deleteArray_exception(void *p);
   static void destruct_exception(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::exception*)
   {
      ::exception *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::exception),0);
      static ::ROOT::TGenericClassInfo 
         instance("exception", "exception.dll", 0,
                  typeid(::exception), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &exception_Dictionary, isa_proxy, 2,
                  sizeof(::exception) );
      instance.SetNew(&new_exception);
      instance.SetNewArray(&newArray_exception);
      instance.SetDelete(&delete_exception);
      instance.SetDeleteArray(&deleteArray_exception);
      instance.SetDestructor(&destruct_exception);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::exception*)
   {
      return GenerateInitInstanceLocal((::exception*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::exception*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void exception_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::exception*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLDataNotFound_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLDataNotFound_Dictionary();
   static void delete_RATcLcLDScLcLDataNotFound(void *p);
   static void deleteArray_RATcLcLDScLcLDataNotFound(void *p);
   static void destruct_RATcLcLDScLcLDataNotFound(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::DataNotFound*)
   {
      ::RAT::DS::DataNotFound *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DS::DataNotFound),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::DataNotFound", "include/RAT/DS/DataNotFound.hh", 37,
                  typeid(::RAT::DS::DataNotFound), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RATcLcLDScLcLDataNotFound_Dictionary, isa_proxy, 2,
                  sizeof(::RAT::DS::DataNotFound) );
      instance.SetDelete(&delete_RATcLcLDScLcLDataNotFound);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDataNotFound);
      instance.SetDestructor(&destruct_RATcLcLDScLcLDataNotFound);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::DataNotFound*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::DataNotFound*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::DataNotFound*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLDataNotFound_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::DataNotFound*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLClassifierResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLClassifierResult(void *p = 0);
   static void *newArray_RATcLcLDScLcLClassifierResult(Long_t size, void *p);
   static void delete_RATcLcLDScLcLClassifierResult(void *p);
   static void deleteArray_RATcLcLDScLcLClassifierResult(void *p);
   static void destruct_RATcLcLDScLcLClassifierResult(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::ClassifierResult*)
   {
      ::RAT::DS::ClassifierResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::ClassifierResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::ClassifierResult", ::RAT::DS::ClassifierResult::Class_Version(), "include/RAT/DS/ClassifierResult.hh", 68,
                  typeid(::RAT::DS::ClassifierResult), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::ClassifierResult::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::ClassifierResult) );
      instance.SetNew(&new_RATcLcLDScLcLClassifierResult);
      instance.SetNewArray(&newArray_RATcLcLDScLcLClassifierResult);
      instance.SetDelete(&delete_RATcLcLDScLcLClassifierResult);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLClassifierResult);
      instance.SetDestructor(&destruct_RATcLcLDScLcLClassifierResult);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::ClassifierResult*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::ClassifierResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLDataQCFlags_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLDataQCFlags(void *p = 0);
   static void *newArray_RATcLcLDScLcLDataQCFlags(Long_t size, void *p);
   static void delete_RATcLcLDScLcLDataQCFlags(void *p);
   static void deleteArray_RATcLcLDScLcLDataQCFlags(void *p);
   static void destruct_RATcLcLDScLcLDataQCFlags(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::DataQCFlags*)
   {
      ::RAT::DS::DataQCFlags *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::DataQCFlags >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::DataQCFlags", ::RAT::DS::DataQCFlags::Class_Version(), "include/RAT/DS/DataQCFlags.hh", 36,
                  typeid(::RAT::DS::DataQCFlags), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::DataQCFlags::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::DataQCFlags) );
      instance.SetNew(&new_RATcLcLDScLcLDataQCFlags);
      instance.SetNewArray(&newArray_RATcLcLDScLcLDataQCFlags);
      instance.SetDelete(&delete_RATcLcLDScLcLDataQCFlags);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDataQCFlags);
      instance.SetDestructor(&destruct_RATcLcLDScLcLDataQCFlags);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::DataQCFlags*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::DataQCFlags*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary();
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p = 0);
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t size, void *p);
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned int,RAT::DS::BitMask>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<unsigned int,RAT::DS::BitMask>) == sizeof( ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
      pair<unsigned int,RAT::DS::BitMask> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned int,RAT::DS::BitMask>),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<unsigned int,RAT::DS::BitMask>", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<unsigned int,RAT::DS::BitMask>), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_ShowMembers, &pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<unsigned int,RAT::DS::BitMask>) );
      instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<unsigned int,RAT::DS::BitMask>*)
   {
      return GenerateInitInstanceLocal((pair<unsigned int,RAT::DS::BitMask>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::BitMask>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::BitMask>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLDigitiser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLDigitiser(void *p = 0);
   static void *newArray_RATcLcLDScLcLDigitiser(Long_t size, void *p);
   static void delete_RATcLcLDScLcLDigitiser(void *p);
   static void deleteArray_RATcLcLDScLcLDigitiser(void *p);
   static void destruct_RATcLcLDScLcLDigitiser(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Digitiser*)
   {
      ::RAT::DS::Digitiser *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Digitiser >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::Digitiser", ::RAT::DS::Digitiser::Class_Version(), "include/RAT/DS/Digitiser.hh", 33,
                  typeid(::RAT::DS::Digitiser), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::Digitiser::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::Digitiser) );
      instance.SetNew(&new_RATcLcLDScLcLDigitiser);
      instance.SetNewArray(&newArray_RATcLcLDScLcLDigitiser);
      instance.SetDelete(&delete_RATcLcLDScLcLDigitiser);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLDigitiser);
      instance.SetDestructor(&destruct_RATcLcLDScLcLDigitiser);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Digitiser*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::Digitiser*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLECAHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLECAHeader(void *p = 0);
   static void *newArray_RATcLcLDScLcLECAHeader(Long_t size, void *p);
   static void delete_RATcLcLDScLcLECAHeader(void *p);
   static void deleteArray_RATcLcLDScLcLECAHeader(void *p);
   static void destruct_RATcLcLDScLcLECAHeader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::ECAHeader*)
   {
      ::RAT::DS::ECAHeader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::ECAHeader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::ECAHeader", ::RAT::DS::ECAHeader::Class_Version(), "include/RAT/DS/ECAHeader.hh", 30,
                  typeid(::RAT::DS::ECAHeader), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::ECAHeader::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::ECAHeader) );
      instance.SetNew(&new_RATcLcLDScLcLECAHeader);
      instance.SetNewArray(&newArray_RATcLcLDScLcLECAHeader);
      instance.SetDelete(&delete_RATcLcLDScLcLECAHeader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLECAHeader);
      instance.SetDestructor(&destruct_RATcLcLDScLcLECAHeader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::ECAHeader*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::ECAHeader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLUniversalTime_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLUniversalTime(void *p = 0);
   static void *newArray_RATcLcLDScLcLUniversalTime(Long_t size, void *p);
   static void delete_RATcLcLDScLcLUniversalTime(void *p);
   static void deleteArray_RATcLcLDScLcLUniversalTime(void *p);
   static void destruct_RATcLcLDScLcLUniversalTime(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::UniversalTime*)
   {
      ::RAT::DS::UniversalTime *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::UniversalTime >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::UniversalTime", ::RAT::DS::UniversalTime::Class_Version(), "include/RAT/DS/UniversalTime.hh", 28,
                  typeid(::RAT::DS::UniversalTime), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::UniversalTime::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::UniversalTime) );
      instance.SetNew(&new_RATcLcLDScLcLUniversalTime);
      instance.SetNewArray(&newArray_RATcLcLDScLcLUniversalTime);
      instance.SetDelete(&delete_RATcLcLDScLcLUniversalTime);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLUniversalTime);
      instance.SetDestructor(&destruct_RATcLcLDScLcLUniversalTime);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::UniversalTime*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::UniversalTime*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary();
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
      ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", "/home/root/include/Math/GenVector/DisplacementVector3D.h", 75,
                  typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers, &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLCartesian3DlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary();
   static void *new_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p);
   static void destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Cartesian3D<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::Cartesian3D<float>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::Cartesian3DlEfloatgR));
      ::ROOT::Math::Cartesian3D<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Cartesian3D<float>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::Cartesian3D<float>", "/home/root/include/Math/GenVector/Cartesian3D.h", 51,
                  typeid(::ROOT::Math::Cartesian3D<float>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLCartesian3DlEfloatgR_ShowMembers, &ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::Cartesian3D<float>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLCartesian3DlEfloatgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Cartesian3D<float>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::Cartesian3D<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Cartesian3D<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLCartesian3DlEfloatgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::Cartesian3D<float>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary();
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
      ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", "/home/root/include/Math/GenVector/DisplacementVector3D.h", 75,
                  typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers, &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary();
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
      ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", "/home/root/include/Math/GenVector/DisplacementVector3D.h", 75,
                  typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers, &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLPolar3DlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary();
   static void *new_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p);
   static void destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Polar3D<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::Polar3D<float>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::Polar3DlEfloatgR));
      ::ROOT::Math::Polar3D<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Polar3D<float>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::Polar3D<float>", "/home/root/include/Math/GenVector/Polar3D.h", 46,
                  typeid(::ROOT::Math::Polar3D<float>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLPolar3DlEfloatgR_ShowMembers, &ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::Polar3D<float>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLPolar3DlEfloatgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLPolar3DlEfloatgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Polar3D<float>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::Polar3D<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Polar3D<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLPolar3DlEfloatgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::Polar3D<float>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary();
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p = 0);
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>) == sizeof( ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
      ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", "/home/root/include/Math/GenVector/DisplacementVector3D.h", 75,
                  typeid(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>), ::ROOT::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers, &ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)
   {
      return GenerateInitInstanceLocal((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLFitVertex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLFitVertex(void *p = 0);
   static void *newArray_RATcLcLDScLcLFitVertex(Long_t size, void *p);
   static void delete_RATcLcLDScLcLFitVertex(void *p);
   static void deleteArray_RATcLcLDScLcLFitVertex(void *p);
   static void destruct_RATcLcLDScLcLFitVertex(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitVertex*)
   {
      ::RAT::DS::FitVertex *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitVertex >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::FitVertex", ::RAT::DS::FitVertex::Class_Version(), "include/RAT/DS/FitVertex.hh", 59,
                  typeid(::RAT::DS::FitVertex), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::FitVertex::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::FitVertex) );
      instance.SetNew(&new_RATcLcLDScLcLFitVertex);
      instance.SetNewArray(&newArray_RATcLcLDScLcLFitVertex);
      instance.SetDelete(&delete_RATcLcLDScLcLFitVertex);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitVertex);
      instance.SetDestructor(&destruct_RATcLcLDScLcLFitVertex);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitVertex*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::FitVertex*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLFitResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLFitResult(void *p = 0);
   static void *newArray_RATcLcLDScLcLFitResult(Long_t size, void *p);
   static void delete_RATcLcLDScLcLFitResult(void *p);
   static void deleteArray_RATcLcLDScLcLFitResult(void *p);
   static void destruct_RATcLcLDScLcLFitResult(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitResult*)
   {
      ::RAT::DS::FitResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::FitResult", ::RAT::DS::FitResult::Class_Version(), "include/RAT/DS/FitResult.hh", 69,
                  typeid(::RAT::DS::FitResult), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::FitResult::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::FitResult) );
      instance.SetNew(&new_RATcLcLDScLcLFitResult);
      instance.SetNewArray(&newArray_RATcLcLDScLcLFitResult);
      instance.SetDelete(&delete_RATcLcLDScLcLFitResult);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitResult);
      instance.SetDestructor(&destruct_RATcLcLDScLcLFitResult);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitResult*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::FitResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary();
   static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p);
   static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p);
   static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::FitClassifierCollectionlERATcLcLDScLcLFitResultgR));
      ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::FitClassifierCollection<RAT::DS::FitResult>", ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class_Version(), "include/RAT/DS/FitClassifierCollection.hh", 33,
                  typeid(::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>) );
      instance.SetNew(&new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
      instance.SetDelete(&delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary();
   static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p);
   static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p);
   static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::FitClassifierCollectionlERATcLcLDScLcLClassifierResultgR));
      ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>", ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Version(), "include/RAT/DS/FitClassifierCollection.hh", 33,
                  typeid(::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>) );
      instance.SetNew(&new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
      instance.SetDelete(&delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void jsoncLcLValue_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void jsoncLcLValue_Dictionary();
   static void *new_jsoncLcLValue(void *p = 0);
   static void *newArray_jsoncLcLValue(Long_t size, void *p);
   static void delete_jsoncLcLValue(void *p);
   static void deleteArray_jsoncLcLValue(void *p);
   static void destruct_jsoncLcLValue(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::json::Value*)
   {
      ::json::Value *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::json::Value),0);
      static ::ROOT::TGenericClassInfo 
         instance("json::Value", "include/RAT/json.hh", 67,
                  typeid(::json::Value), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &jsoncLcLValue_Dictionary, isa_proxy, 0,
                  sizeof(::json::Value) );
      instance.SetNew(&new_jsoncLcLValue);
      instance.SetNewArray(&newArray_jsoncLcLValue);
      instance.SetDelete(&delete_jsoncLcLValue);
      instance.SetDeleteArray(&deleteArray_jsoncLcLValue);
      instance.SetDestructor(&destruct_jsoncLcLValue);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::json::Value*)
   {
      return GenerateInitInstanceLocal((::json::Value*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::json::Value*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void jsoncLcLValue_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::json::Value*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLog_Dictionary();
   static void *new_RATcLcLLog(void *p = 0);
   static void delete_RATcLcLLog(void *p);
   static void deleteArray_RATcLcLLog(void *p);
   static void destruct_RATcLcLLog(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::Log*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::Log) == sizeof( ::ROOTShadow::Shadow::RAT::Log));
      ::RAT::Log *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::Log),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::Log", "include/RAT/Log.hh", 126,
                  typeid(::RAT::Log), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLog_ShowMembers, &RATcLcLLog_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::Log) );
      instance.SetNew(&new_RATcLcLLog);
      instance.SetDelete(&delete_RATcLcLLog);
      instance.SetDeleteArray(&deleteArray_RATcLcLLog);
      instance.SetDestructor(&destruct_RATcLcLLog);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::Log*)
   {
      return GenerateInitInstanceLocal((::RAT::Log*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::Log*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLog_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::Log*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLBitManip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLBitManip_Dictionary();
   static void *new_RATcLcLBitManip(void *p = 0);
   static void *newArray_RATcLcLBitManip(Long_t size, void *p);
   static void delete_RATcLcLBitManip(void *p);
   static void deleteArray_RATcLcLBitManip(void *p);
   static void destruct_RATcLcLBitManip(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::BitManip*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::BitManip) == sizeof( ::ROOTShadow::Shadow::RAT::BitManip));
      ::RAT::BitManip *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::BitManip),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::BitManip", "include/RAT/BitManip.hh", 22,
                  typeid(::RAT::BitManip), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLBitManip_ShowMembers, &RATcLcLBitManip_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::BitManip) );
      instance.SetNew(&new_RATcLcLBitManip);
      instance.SetNewArray(&newArray_RATcLcLBitManip);
      instance.SetDelete(&delete_RATcLcLBitManip);
      instance.SetDeleteArray(&deleteArray_RATcLcLBitManip);
      instance.SetDestructor(&destruct_RATcLcLBitManip);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::BitManip*)
   {
      return GenerateInitInstanceLocal((::RAT::BitManip*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::BitManip*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLBitManip_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::BitManip*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTCal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLPMTCal(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTCal(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTCal(void *p);
   static void deleteArray_RATcLcLDScLcLPMTCal(void *p);
   static void destruct_RATcLcLDScLcLPMTCal(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTCal*)
   {
      ::RAT::DS::PMTCal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTCal >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMTCal", ::RAT::DS::PMTCal::Class_Version(), "include/RAT/DS/PMT.hh", 224,
                  typeid(::RAT::DS::PMTCal), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::PMTCal::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMTCal) );
      instance.SetNew(&new_RATcLcLDScLcLPMTCal);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTCal);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTCal);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTCal);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTCal);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTCal*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::PMTCal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTlEDouble32_tgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary();
   static void *new_RATcLcLDScLcLPMTlEDouble32_tgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTlEDouble32_tgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTlEDouble32_tgR(void *p);
   static void deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR(void *p);
   static void destruct_RATcLcLDScLcLPMTlEDouble32_tgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMT<Double32_t>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::PMT<Double32_t>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::PMTlEDouble32_tgR));
      ::RAT::DS::PMT<Double32_t> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMT<Double32_t> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMT<Double32_t>", ::RAT::DS::PMT<Double32_t>::Class_Version(), "include/RAT/DS/PMT.hh", 55,
                  typeid(::RAT::DS::PMT<Double32_t>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMT<Double32_t>) );
      instance.SetNew(&new_RATcLcLDScLcLPMTlEDouble32_tgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTlEDouble32_tgR);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTlEDouble32_tgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTlEDouble32_tgR);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLPMTlEDouble32_tgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTlEunsignedsPshortgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary();
   static void *new_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p);
   static void deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p);
   static void destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMT<unsigned short>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::PMT<unsigned short>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::PMTlEunsignedsPshortgR));
      ::RAT::DS::PMT<unsigned short> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMT<unsigned short> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMT<unsigned short>", ::RAT::DS::PMT<unsigned short>::Class_Version(), "include/RAT/DS/PMT.hh", 55,
                  typeid(::RAT::DS::PMT<unsigned short>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMT<unsigned short>) );
      instance.SetNew(&new_RATcLcLDScLcLPMTlEunsignedsPshortgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTlEunsignedsPshortgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMT<unsigned short>*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::PMT<unsigned short>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLPMTlEunsignedsPshortgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCHit(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCHit(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCHit(void *p);
   static void deleteArray_RATcLcLDScLcLMCHit(void *p);
   static void destruct_RATcLcLDScLcLMCHit(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCHit*)
   {
      ::RAT::DS::MCHit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCHit", ::RAT::DS::MCHit::Class_Version(), "include/RAT/DS/MCHit.hh", 34,
                  typeid(::RAT::DS::MCHit), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCHit::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCHit) );
      instance.SetNew(&new_RATcLcLDScLcLMCHit);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCHit);
      instance.SetDelete(&delete_RATcLcLDScLcLMCHit);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCHit);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCHit);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCHit*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLPMTInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLPMTInfo(void *p = 0);
   static void *newArray_RATcLcLDUcLcLPMTInfo(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLPMTInfo(void *p);
   static void deleteArray_RATcLcLDUcLcLPMTInfo(void *p);
   static void destruct_RATcLcLDUcLcLPMTInfo(void *p);
   static void streamer_RATcLcLDUcLcLPMTInfo(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PMTInfo*)
   {
      ::RAT::DU::PMTInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PMTInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::PMTInfo", ::RAT::DU::PMTInfo::Class_Version(), "include/RAT/DU/PMTInfo.hh", 48,
                  typeid(::RAT::DU::PMTInfo), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::PMTInfo::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::PMTInfo) );
      instance.SetNew(&new_RATcLcLDUcLcLPMTInfo);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLPMTInfo);
      instance.SetDelete(&delete_RATcLcLDUcLcLPMTInfo);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPMTInfo);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLPMTInfo);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPMTInfo);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PMTInfo*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::PMTInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary();
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >) == sizeof( ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR));
      ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >", ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class_Version(), "include/RAT/DS/PMTSet.hh", 49,
                  typeid(::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >) );
      instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary();
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p);
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p);
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::PMTSet<RAT::DS::PMTCal>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLPMTCalgR));
      ::RAT::DS::PMTSet<RAT::DS::PMTCal> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet<RAT::DS::PMTCal> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMTSet<RAT::DS::PMTCal>", ::RAT::DS::PMTSet<RAT::DS::PMTCal>::Class_Version(), "include/RAT/DS/PMTSet.hh", 49,
                  typeid(::RAT::DS::PMTSet<RAT::DS::PMTCal>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMTSet<RAT::DS::PMTCal>) );
      instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary();
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p = 0);
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(Long_t size, void *p);
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p);
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p);
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DS::PMTSet<RAT::DS::MCHit>) == sizeof( ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLMCHitgR));
      ::RAT::DS::PMTSet<RAT::DS::MCHit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::PMTSet<RAT::DS::MCHit> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::PMTSet<RAT::DS::MCHit>", ::RAT::DS::PMTSet<RAT::DS::MCHit>::Class_Version(), "include/RAT/DS/PMTSet.hh", 49,
                  typeid(::RAT::DS::PMTSet<RAT::DS::MCHit>), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::PMTSet<RAT::DS::MCHit>) );
      instance.SetNew(&new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
      instance.SetNewArray(&newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
      instance.SetDelete(&delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
      instance.SetDestructor(&destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::PMTSet<RAT::DS::MCHit>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLEV_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLEV(void *p = 0);
   static void *newArray_RATcLcLDScLcLEV(Long_t size, void *p);
   static void delete_RATcLcLDScLcLEV(void *p);
   static void deleteArray_RATcLcLDScLcLEV(void *p);
   static void destruct_RATcLcLDScLcLEV(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::EV*)
   {
      ::RAT::DS::EV *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::EV >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::EV", ::RAT::DS::EV::Class_Version(), "include/RAT/DS/EV.hh", 68,
                  typeid(::RAT::DS::EV), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::EV::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::EV) );
      instance.SetNew(&new_RATcLcLDScLcLEV);
      instance.SetNewArray(&newArray_RATcLcLDScLcLEV);
      instance.SetDelete(&delete_RATcLcLDScLcLEV);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLEV);
      instance.SetDestructor(&destruct_RATcLcLDScLcLEV);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::EV*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::EV*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::EV*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary();
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p = 0);
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t size, void *p);
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >) == sizeof( ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
      pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_ShowMembers, &pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >) );
      instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)
   {
      return GenerateInitInstanceLocal((pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary();
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p = 0);
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t size, void *p);
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >) == sizeof( ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
      pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_ShowMembers, &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >) );
      instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)
   {
      return GenerateInitInstanceLocal((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary();
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p = 0);
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t size, void *p);
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >) == sizeof( ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
      pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_ShowMembers, &pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >) );
      instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)
   {
      return GenerateInitInstanceLocal((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLTrigHeader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLTrigHeader(void *p = 0);
   static void *newArray_RATcLcLDScLcLTrigHeader(Long_t size, void *p);
   static void delete_RATcLcLDScLcLTrigHeader(void *p);
   static void deleteArray_RATcLcLDScLcLTrigHeader(void *p);
   static void destruct_RATcLcLDScLcLTrigHeader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::TrigHeader*)
   {
      ::RAT::DS::TrigHeader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::TrigHeader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::TrigHeader", ::RAT::DS::TrigHeader::Class_Version(), "include/RAT/DS/TrigHeader.hh", 33,
                  typeid(::RAT::DS::TrigHeader), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::TrigHeader::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::TrigHeader) );
      instance.SetNew(&new_RATcLcLDScLcLTrigHeader);
      instance.SetNewArray(&newArray_RATcLcLDScLcLTrigHeader);
      instance.SetDelete(&delete_RATcLcLDScLcLTrigHeader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLTrigHeader);
      instance.SetDestructor(&destruct_RATcLcLDScLcLTrigHeader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::TrigHeader*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::TrigHeader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLHeaderInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLHeaderInfo(void *p = 0);
   static void *newArray_RATcLcLDScLcLHeaderInfo(Long_t size, void *p);
   static void delete_RATcLcLDScLcLHeaderInfo(void *p);
   static void deleteArray_RATcLcLDScLcLHeaderInfo(void *p);
   static void destruct_RATcLcLDScLcLHeaderInfo(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::HeaderInfo*)
   {
      ::RAT::DS::HeaderInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::HeaderInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::HeaderInfo", ::RAT::DS::HeaderInfo::Class_Version(), "include/RAT/DS/HeaderInfo.hh", 39,
                  typeid(::RAT::DS::HeaderInfo), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::HeaderInfo::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::HeaderInfo) );
      instance.SetNew(&new_RATcLcLDScLcLHeaderInfo);
      instance.SetNewArray(&newArray_RATcLcLDScLcLHeaderInfo);
      instance.SetDelete(&delete_RATcLcLDScLcLHeaderInfo);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLHeaderInfo);
      instance.SetDestructor(&destruct_RATcLcLDScLcLHeaderInfo);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::HeaderInfo*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::HeaderInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMetaDB_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMetaDB(void *p = 0);
   static void *newArray_RATcLcLDScLcLMetaDB(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMetaDB(void *p);
   static void deleteArray_RATcLcLDScLcLMetaDB(void *p);
   static void destruct_RATcLcLDScLcLMetaDB(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MetaDB*)
   {
      ::RAT::DS::MetaDB *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MetaDB >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MetaDB", ::RAT::DS::MetaDB::Class_Version(), "include/RAT/DS/MetaDB.hh", 30,
                  typeid(::RAT::DS::MetaDB), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MetaDB::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MetaDB) );
      instance.SetNew(&new_RATcLcLDScLcLMetaDB);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMetaDB);
      instance.SetDelete(&delete_RATcLcLDScLcLMetaDB);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMetaDB);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMetaDB);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MetaDB*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MetaDB*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEstringcOstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEstringcOstringgR_Dictionary();
   static void *new_pairlEstringcOstringgR(void *p = 0);
   static void *newArray_pairlEstringcOstringgR(Long_t size, void *p);
   static void delete_pairlEstringcOstringgR(void *p);
   static void deleteArray_pairlEstringcOstringgR(void *p);
   static void destruct_pairlEstringcOstringgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<string,string>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<string,string>) == sizeof( ::ROOTShadow::Shadow::pairlEstringcOstringgR));
      pair<string,string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<string,string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<string,string>", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<string,string>), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEstringcOstringgR_ShowMembers, &pairlEstringcOstringgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<string,string>) );
      instance.SetNew(&new_pairlEstringcOstringgR);
      instance.SetNewArray(&newArray_pairlEstringcOstringgR);
      instance.SetDelete(&delete_pairlEstringcOstringgR);
      instance.SetDeleteArray(&deleteArray_pairlEstringcOstringgR);
      instance.SetDestructor(&destruct_pairlEstringcOstringgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<string,string>*)
   {
      return GenerateInitInstanceLocal((pair<string,string>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<string,string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEstringcOstringgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<string,string>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLRun_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLRun(void *p = 0);
   static void *newArray_RATcLcLDScLcLRun(Long_t size, void *p);
   static void delete_RATcLcLDScLcLRun(void *p);
   static void deleteArray_RATcLcLDScLcLRun(void *p);
   static void destruct_RATcLcLDScLcLRun(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Run*)
   {
      ::RAT::DS::Run *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Run >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::Run", ::RAT::DS::Run::Class_Version(), "include/RAT/DS/Run.hh", 48,
                  typeid(::RAT::DS::Run), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::Run::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::Run) );
      instance.SetNew(&new_RATcLcLDScLcLRun);
      instance.SetNewArray(&newArray_RATcLcLDScLcLRun);
      instance.SetDelete(&delete_RATcLcLDScLcLRun);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLRun);
      instance.SetDestructor(&destruct_RATcLcLDScLcLRun);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Run*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::Run*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::Run*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMeta_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMeta(void *p = 0);
   static void *newArray_RATcLcLDScLcLMeta(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMeta(void *p);
   static void deleteArray_RATcLcLDScLcLMeta(void *p);
   static void destruct_RATcLcLDScLcLMeta(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Meta*)
   {
      ::RAT::DS::Meta *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Meta >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::Meta", ::RAT::DS::Meta::Class_Version(), "include/RAT/DS/Meta.hh", 35,
                  typeid(::RAT::DS::Meta), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::Meta::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::Meta) );
      instance.SetNew(&new_RATcLcLDScLcLMeta);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMeta);
      instance.SetDelete(&delete_RATcLcLDScLcLMeta);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMeta);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMeta);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Meta*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::Meta*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::Meta*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCParticle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCParticle(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCParticle(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCParticle(void *p);
   static void deleteArray_RATcLcLDScLcLMCParticle(void *p);
   static void destruct_RATcLcLDScLcLMCParticle(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCParticle*)
   {
      ::RAT::DS::MCParticle *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCParticle >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCParticle", ::RAT::DS::MCParticle::Class_Version(), "include/RAT/DS/MCParticle.hh", 28,
                  typeid(::RAT::DS::MCParticle), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCParticle::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCParticle) );
      instance.SetNew(&new_RATcLcLDScLcLMCParticle);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCParticle);
      instance.SetDelete(&delete_RATcLcLDScLcLMCParticle);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCParticle);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCParticle);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCParticle*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCParticle*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCTrackStep_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCTrackStep(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCTrackStep(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCTrackStep(void *p);
   static void deleteArray_RATcLcLDScLcLMCTrackStep(void *p);
   static void destruct_RATcLcLDScLcLMCTrackStep(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCTrackStep*)
   {
      ::RAT::DS::MCTrackStep *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCTrackStep >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCTrackStep", ::RAT::DS::MCTrackStep::Class_Version(), "include/RAT/DS/MCTrackStep.hh", 40,
                  typeid(::RAT::DS::MCTrackStep), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCTrackStep::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCTrackStep) );
      instance.SetNew(&new_RATcLcLDScLcLMCTrackStep);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCTrackStep);
      instance.SetDelete(&delete_RATcLcLDScLcLMCTrackStep);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCTrackStep);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCTrackStep);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCTrackStep*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCTrackStep*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCTrack(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCTrack(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCTrack(void *p);
   static void deleteArray_RATcLcLDScLcLMCTrack(void *p);
   static void destruct_RATcLcLDScLcLMCTrack(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCTrack*)
   {
      ::RAT::DS::MCTrack *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCTrack", ::RAT::DS::MCTrack::Class_Version(), "include/RAT/DS/MCTrack.hh", 36,
                  typeid(::RAT::DS::MCTrack), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCTrack::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCTrack) );
      instance.SetNew(&new_RATcLcLDScLcLMCTrack);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCTrack);
      instance.SetDelete(&delete_RATcLcLDScLcLMCTrack);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCTrack);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCTrack);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCTrack*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCPhoton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCPhoton(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCPhoton(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCPhoton(void *p);
   static void deleteArray_RATcLcLDScLcLMCPhoton(void *p);
   static void destruct_RATcLcLDScLcLMCPhoton(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPhoton*)
   {
      ::RAT::DS::MCPhoton *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPhoton >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCPhoton", ::RAT::DS::MCPhoton::Class_Version(), "include/RAT/DS/MCPhoton.hh", 53,
                  typeid(::RAT::DS::MCPhoton), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCPhoton::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCPhoton) );
      instance.SetNew(&new_RATcLcLDScLcLMCPhoton);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCPhoton);
      instance.SetDelete(&delete_RATcLcLDScLcLMCPhoton);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPhoton);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCPhoton);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPhoton*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCPhoton*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCPE_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCPE(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCPE(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCPE(void *p);
   static void deleteArray_RATcLcLDScLcLMCPE(void *p);
   static void destruct_RATcLcLDScLcLMCPE(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPE*)
   {
      ::RAT::DS::MCPE *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPE >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCPE", ::RAT::DS::MCPE::Class_Version(), "include/RAT/DS/MCPE.hh", 53,
                  typeid(::RAT::DS::MCPE), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCPE::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCPE) );
      instance.SetNew(&new_RATcLcLDScLcLMCPE);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCPE);
      instance.SetDelete(&delete_RATcLcLDScLcLMCPE);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPE);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCPE);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPE*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCPE*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCPMT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCPMT(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCPMT(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCPMT(void *p);
   static void deleteArray_RATcLcLDScLcLMCPMT(void *p);
   static void destruct_RATcLcLDScLcLMCPMT(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCPMT*)
   {
      ::RAT::DS::MCPMT *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCPMT >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCPMT", ::RAT::DS::MCPMT::Class_Version(), "include/RAT/DS/MCPMT.hh", 35,
                  typeid(::RAT::DS::MCPMT), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCPMT::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCPMT) );
      instance.SetNew(&new_RATcLcLDScLcLMCPMT);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCPMT);
      instance.SetDelete(&delete_RATcLcLDScLcLMCPMT);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCPMT);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCPMT);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCPMT*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCPMT*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMC(void *p = 0);
   static void *newArray_RATcLcLDScLcLMC(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMC(void *p);
   static void deleteArray_RATcLcLDScLcLMC(void *p);
   static void destruct_RATcLcLDScLcLMC(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MC*)
   {
      ::RAT::DS::MC *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MC >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MC", ::RAT::DS::MC::Class_Version(), "include/RAT/DS/MC.hh", 52,
                  typeid(::RAT::DS::MC), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MC::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MC) );
      instance.SetNew(&new_RATcLcLDScLcLMC);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMC);
      instance.SetDelete(&delete_RATcLcLDScLcLMC);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMC);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMC);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MC*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MC*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLMCEV_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLMCEV(void *p = 0);
   static void *newArray_RATcLcLDScLcLMCEV(Long_t size, void *p);
   static void delete_RATcLcLDScLcLMCEV(void *p);
   static void deleteArray_RATcLcLDScLcLMCEV(void *p);
   static void destruct_RATcLcLDScLcLMCEV(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::MCEV*)
   {
      ::RAT::DS::MCEV *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::MCEV >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::MCEV", ::RAT::DS::MCEV::Class_Version(), "include/RAT/DS/MCEV.hh", 35,
                  typeid(::RAT::DS::MCEV), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::MCEV::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::MCEV) );
      instance.SetNew(&new_RATcLcLDScLcLMCEV);
      instance.SetNewArray(&newArray_RATcLcLDScLcLMCEV);
      instance.SetDelete(&delete_RATcLcLDScLcLMCEV);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLMCEV);
      instance.SetDestructor(&destruct_RATcLcLDScLcLMCEV);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::MCEV*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::MCEV*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLEntry(void *p = 0);
   static void *newArray_RATcLcLDScLcLEntry(Long_t size, void *p);
   static void delete_RATcLcLDScLcLEntry(void *p);
   static void deleteArray_RATcLcLDScLcLEntry(void *p);
   static void destruct_RATcLcLDScLcLEntry(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::Entry*)
   {
      ::RAT::DS::Entry *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::Entry >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::Entry", ::RAT::DS::Entry::Class_Version(), "include/RAT/DS/Entry.hh", 66,
                  typeid(::RAT::DS::Entry), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::Entry::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::Entry) );
      instance.SetNew(&new_RATcLcLDScLcLEntry);
      instance.SetNewArray(&newArray_RATcLcLDScLcLEntry);
      instance.SetDelete(&delete_RATcLcLDScLcLEntry);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLEntry);
      instance.SetDestructor(&destruct_RATcLcLDScLcLEntry);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::Entry*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::Entry*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::Entry*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLSOCPMT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLSOCPMT(void *p = 0);
   static void *newArray_RATcLcLDScLcLSOCPMT(Long_t size, void *p);
   static void delete_RATcLcLDScLcLSOCPMT(void *p);
   static void deleteArray_RATcLcLDScLcLSOCPMT(void *p);
   static void destruct_RATcLcLDScLcLSOCPMT(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::SOCPMT*)
   {
      ::RAT::DS::SOCPMT *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::SOCPMT >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::SOCPMT", ::RAT::DS::SOCPMT::Class_Version(), "include/RAT/DS/SOCPMT.hh", 35,
                  typeid(::RAT::DS::SOCPMT), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::SOCPMT::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::SOCPMT) );
      instance.SetNew(&new_RATcLcLDScLcLSOCPMT);
      instance.SetNewArray(&newArray_RATcLcLDScLcLSOCPMT);
      instance.SetDelete(&delete_RATcLcLDScLcLSOCPMT);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLSOCPMT);
      instance.SetDestructor(&destruct_RATcLcLDScLcLSOCPMT);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::SOCPMT*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::SOCPMT*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDScLcLSOC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDScLcLSOC(void *p = 0);
   static void *newArray_RATcLcLDScLcLSOC(Long_t size, void *p);
   static void delete_RATcLcLDScLcLSOC(void *p);
   static void deleteArray_RATcLcLDScLcLSOC(void *p);
   static void destruct_RATcLcLDScLcLSOC(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DS::SOC*)
   {
      ::RAT::DS::SOC *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DS::SOC >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DS::SOC", ::RAT::DS::SOC::Class_Version(), "include/RAT/DS/SOC.hh", 41,
                  typeid(::RAT::DS::SOC), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DS::SOC::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DS::SOC) );
      instance.SetNew(&new_RATcLcLDScLcLSOC);
      instance.SetNewArray(&newArray_RATcLcLDScLcLSOC);
      instance.SetDelete(&delete_RATcLcLDScLcLSOC);
      instance.SetDeleteArray(&deleteArray_RATcLcLDScLcLSOC);
      instance.SetDestructor(&destruct_RATcLcLDScLcLSOC);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DS::SOC*)
   {
      return GenerateInitInstanceLocal((::RAT::DS::SOC*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DS::SOC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary();
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p = 0);
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t size, void *p);
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const pair<unsigned int,RAT::DS::SOCPMT>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(pair<unsigned int,RAT::DS::SOCPMT>) == sizeof( ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
      pair<unsigned int,RAT::DS::SOCPMT> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<unsigned int,RAT::DS::SOCPMT>),0);
      static ::ROOT::TGenericClassInfo 
         instance("pair<unsigned int,RAT::DS::SOCPMT>", "/home/root/cint/cint/lib/prec_stl/utility", 17,
                  typeid(pair<unsigned int,RAT::DS::SOCPMT>), ::ROOT::DefineBehavior(ptr, ptr),
                  &pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_ShowMembers, &pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary, isa_proxy, 4,
                  sizeof(pair<unsigned int,RAT::DS::SOCPMT>) );
      instance.SetNew(&new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetNewArray(&newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDelete(&delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDeleteArray(&deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDestructor(&destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const pair<unsigned int,RAT::DS::SOCPMT>*)
   {
      return GenerateInitInstanceLocal((pair<unsigned int,RAT::DS::SOCPMT>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::SOCPMT>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::SOCPMT>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLDataCleaningBits_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLDataCleaningBits(void *p = 0);
   static void *newArray_RATcLcLDUcLcLDataCleaningBits(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLDataCleaningBits(void *p);
   static void deleteArray_RATcLcLDUcLcLDataCleaningBits(void *p);
   static void destruct_RATcLcLDUcLcLDataCleaningBits(void *p);
   static void streamer_RATcLcLDUcLcLDataCleaningBits(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DataCleaningBits*)
   {
      ::RAT::DU::DataCleaningBits *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DataCleaningBits >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::DataCleaningBits", ::RAT::DU::DataCleaningBits::Class_Version(), "include/RAT/DU/DataCleaningBits.hh", 34,
                  typeid(::RAT::DU::DataCleaningBits), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::DataCleaningBits::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::DataCleaningBits) );
      instance.SetNew(&new_RATcLcLDUcLcLDataCleaningBits);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLDataCleaningBits);
      instance.SetDelete(&delete_RATcLcLDUcLcLDataCleaningBits);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDataCleaningBits);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLDataCleaningBits);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDataCleaningBits);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DataCleaningBits*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::DataCleaningBits*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLDataQualityBits_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLDataQualityBits(void *p = 0);
   static void *newArray_RATcLcLDUcLcLDataQualityBits(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLDataQualityBits(void *p);
   static void deleteArray_RATcLcLDUcLcLDataQualityBits(void *p);
   static void destruct_RATcLcLDUcLcLDataQualityBits(void *p);
   static void streamer_RATcLcLDUcLcLDataQualityBits(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DataQualityBits*)
   {
      ::RAT::DU::DataQualityBits *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DataQualityBits >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::DataQualityBits", ::RAT::DU::DataQualityBits::Class_Version(), "include/RAT/DU/DataQualityBits.hh", 35,
                  typeid(::RAT::DU::DataQualityBits), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::DataQualityBits::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::DataQualityBits) );
      instance.SetNew(&new_RATcLcLDUcLcLDataQualityBits);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLDataQualityBits);
      instance.SetDelete(&delete_RATcLcLDUcLcLDataQualityBits);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDataQualityBits);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLDataQualityBits);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDataQualityBits);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DataQualityBits*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::DataQualityBits*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLChanSWStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLChanSWStatus(void *p = 0);
   static void *newArray_RATcLcLDUcLcLChanSWStatus(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLChanSWStatus(void *p);
   static void deleteArray_RATcLcLDUcLcLChanSWStatus(void *p);
   static void destruct_RATcLcLDUcLcLChanSWStatus(void *p);
   static void streamer_RATcLcLDUcLcLChanSWStatus(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ChanSWStatus*)
   {
      ::RAT::DU::ChanSWStatus *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::ChanSWStatus >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ChanSWStatus", ::RAT::DU::ChanSWStatus::Class_Version(), "include/RAT/DU/ChanSWStatus.hh", 29,
                  typeid(::RAT::DU::ChanSWStatus), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::ChanSWStatus::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::ChanSWStatus) );
      instance.SetNew(&new_RATcLcLDUcLcLChanSWStatus);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLChanSWStatus);
      instance.SetDelete(&delete_RATcLcLDUcLcLChanSWStatus);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLChanSWStatus);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLChanSWStatus);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLChanSWStatus);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ChanSWStatus*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ChanSWStatus*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLTrigBits_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLTrigBits(void *p = 0);
   static void *newArray_RATcLcLDUcLcLTrigBits(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLTrigBits(void *p);
   static void deleteArray_RATcLcLDUcLcLTrigBits(void *p);
   static void destruct_RATcLcLDUcLcLTrigBits(void *p);
   static void streamer_RATcLcLDUcLcLTrigBits(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::TrigBits*)
   {
      ::RAT::DU::TrigBits *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::TrigBits >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::TrigBits", ::RAT::DU::TrigBits::Class_Version(), "include/RAT/DU/TrigBits.hh", 30,
                  typeid(::RAT::DU::TrigBits), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::TrigBits::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::TrigBits) );
      instance.SetNew(&new_RATcLcLDUcLcLTrigBits);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLTrigBits);
      instance.SetDelete(&delete_RATcLcLDUcLcLTrigBits);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLTrigBits);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLTrigBits);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLTrigBits);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::TrigBits*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::TrigBits*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLDSReader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RATcLcLDUcLcLDSReader(void *p);
   static void deleteArray_RATcLcLDUcLcLDSReader(void *p);
   static void destruct_RATcLcLDUcLcLDSReader(void *p);
   static void streamer_RATcLcLDUcLcLDSReader(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::DSReader*)
   {
      ::RAT::DU::DSReader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::DSReader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::DSReader", ::RAT::DU::DSReader::Class_Version(), "include/RAT/DU/DSReader.hh", 51,
                  typeid(::RAT::DU::DSReader), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::DSReader::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::DSReader) );
      instance.SetDelete(&delete_RATcLcLDUcLcLDSReader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLDSReader);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLDSReader);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLDSReader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::DSReader*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::DSReader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLEffectiveVelocity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLEffectiveVelocity(void *p = 0);
   static void *newArray_RATcLcLDUcLcLEffectiveVelocity(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLEffectiveVelocity(void *p);
   static void deleteArray_RATcLcLDUcLcLEffectiveVelocity(void *p);
   static void destruct_RATcLcLDUcLcLEffectiveVelocity(void *p);
   static void streamer_RATcLcLDUcLcLEffectiveVelocity(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::EffectiveVelocity*)
   {
      ::RAT::DU::EffectiveVelocity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::EffectiveVelocity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::EffectiveVelocity", ::RAT::DU::EffectiveVelocity::Class_Version(), "include/RAT/DU/EffectiveVelocity.hh", 34,
                  typeid(::RAT::DU::EffectiveVelocity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::EffectiveVelocity::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::EffectiveVelocity) );
      instance.SetNew(&new_RATcLcLDUcLcLEffectiveVelocity);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLEffectiveVelocity);
      instance.SetDelete(&delete_RATcLcLDUcLcLEffectiveVelocity);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLEffectiveVelocity);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLEffectiveVelocity);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLEffectiveVelocity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::EffectiveVelocity*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::EffectiveVelocity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDBTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDBTable_Dictionary();
   static void *new_RATcLcLDBTable(void *p = 0);
   static void *newArray_RATcLcLDBTable(Long_t size, void *p);
   static void delete_RATcLcLDBTable(void *p);
   static void deleteArray_RATcLcLDBTable(void *p);
   static void destruct_RATcLcLDBTable(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBTable*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DBTable) == sizeof( ::ROOTShadow::Shadow::RAT::DBTable));
      ::RAT::DBTable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBTable),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DBTable", "include/RAT/DBTable.hh", 21,
                  typeid(::RAT::DBTable), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDBTable_ShowMembers, &RATcLcLDBTable_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DBTable) );
      instance.SetNew(&new_RATcLcLDBTable);
      instance.SetNewArray(&newArray_RATcLcLDBTable);
      instance.SetDelete(&delete_RATcLcLDBTable);
      instance.SetDeleteArray(&deleteArray_RATcLcLDBTable);
      instance.SetDestructor(&destruct_RATcLcLDBTable);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DBTable*)
   {
      return GenerateInitInstanceLocal((::RAT::DBTable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DBTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDBTable_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBTable*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDB_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDB(void *p = 0);
   static void *newArray_RATcLcLDB(Long_t size, void *p);
   static void delete_RATcLcLDB(void *p);
   static void deleteArray_RATcLcLDB(void *p);
   static void destruct_RATcLcLDB(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DB*)
   {
      ::RAT::DB *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DB >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DB", ::RAT::DB::Class_Version(), "include/RAT/DB.hh", 203,
                  typeid(::RAT::DB), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DB::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DB) );
      instance.SetNew(&new_RATcLcLDB);
      instance.SetNewArray(&newArray_RATcLcLDB);
      instance.SetDelete(&delete_RATcLcLDB);
      instance.SetDeleteArray(&deleteArray_RATcLcLDB);
      instance.SetDestructor(&destruct_RATcLcLDB);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DB*)
   {
      return GenerateInitInstanceLocal((::RAT::DB*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDBLink_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDBLink_Dictionary();
   static void delete_RATcLcLDBLink(void *p);
   static void deleteArray_RATcLcLDBLink(void *p);
   static void destruct_RATcLcLDBLink(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBLink*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DBLink) == sizeof( ::ROOTShadow::Shadow::RAT::DBLink));
      ::RAT::DBLink *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBLink),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DBLink", "include/RAT/DBLink.hh", 51,
                  typeid(::RAT::DBLink), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDBLink_ShowMembers, &RATcLcLDBLink_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DBLink) );
      instance.SetDelete(&delete_RATcLcLDBLink);
      instance.SetDeleteArray(&deleteArray_RATcLcLDBLink);
      instance.SetDestructor(&destruct_RATcLcLDBLink);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DBLink*)
   {
      return GenerateInitInstanceLocal((::RAT::DBLink*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DBLink*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDBLink_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBLink*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLPgSQLBackend_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLPgSQLBackend_Dictionary();
   static void *new_RATcLcLPgSQLBackend(void *p = 0);
   static void *newArray_RATcLcLPgSQLBackend(Long_t size, void *p);
   static void delete_RATcLcLPgSQLBackend(void *p);
   static void deleteArray_RATcLcLPgSQLBackend(void *p);
   static void destruct_RATcLcLPgSQLBackend(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::PgSQLBackend*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::PgSQLBackend) == sizeof( ::ROOTShadow::Shadow::RAT::PgSQLBackend));
      ::RAT::PgSQLBackend *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::PgSQLBackend),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::PgSQLBackend", "include/RAT/PgSQLBackend.hh", 28,
                  typeid(::RAT::PgSQLBackend), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLPgSQLBackend_ShowMembers, &RATcLcLPgSQLBackend_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::PgSQLBackend) );
      instance.SetNew(&new_RATcLcLPgSQLBackend);
      instance.SetNewArray(&newArray_RATcLcLPgSQLBackend);
      instance.SetDelete(&delete_RATcLcLPgSQLBackend);
      instance.SetDeleteArray(&deleteArray_RATcLcLPgSQLBackend);
      instance.SetDestructor(&destruct_RATcLcLPgSQLBackend);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::PgSQLBackend*)
   {
      return GenerateInitInstanceLocal((::RAT::PgSQLBackend*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::PgSQLBackend*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLPgSQLBackend_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::PgSQLBackend*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void simple_ptr_nocopylERATcLcLDBTablegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void simple_ptr_nocopylERATcLcLDBTablegR_Dictionary();
   static void *new_simple_ptr_nocopylERATcLcLDBTablegR(void *p = 0);
   static void *newArray_simple_ptr_nocopylERATcLcLDBTablegR(Long_t size, void *p);
   static void delete_simple_ptr_nocopylERATcLcLDBTablegR(void *p);
   static void deleteArray_simple_ptr_nocopylERATcLcLDBTablegR(void *p);
   static void destruct_simple_ptr_nocopylERATcLcLDBTablegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::simple_ptr_nocopy<RAT::DBTable>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::simple_ptr_nocopy<RAT::DBTable>) == sizeof( ::ROOTShadow::Shadow::simple_ptr_nocopylERATcLcLDBTablegR));
      ::simple_ptr_nocopy<RAT::DBTable> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simple_ptr_nocopy<RAT::DBTable>),0);
      static ::ROOT::TGenericClassInfo 
         instance("simple_ptr_nocopy<RAT::DBTable>", "include/external/stlplus/smart_ptr.hpp", 354,
                  typeid(::simple_ptr_nocopy<RAT::DBTable>), ::ROOT::DefineBehavior(ptr, ptr),
                  &simple_ptr_nocopylERATcLcLDBTablegR_ShowMembers, &simple_ptr_nocopylERATcLcLDBTablegR_Dictionary, isa_proxy, 4,
                  sizeof(::simple_ptr_nocopy<RAT::DBTable>) );
      instance.SetNew(&new_simple_ptr_nocopylERATcLcLDBTablegR);
      instance.SetNewArray(&newArray_simple_ptr_nocopylERATcLcLDBTablegR);
      instance.SetDelete(&delete_simple_ptr_nocopylERATcLcLDBTablegR);
      instance.SetDeleteArray(&deleteArray_simple_ptr_nocopylERATcLcLDBTablegR);
      instance.SetDestructor(&destruct_simple_ptr_nocopylERATcLcLDBTablegR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::simple_ptr_nocopy<RAT::DBTable>*)
   {
      return GenerateInitInstanceLocal((::simple_ptr_nocopy<RAT::DBTable>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBTable>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void simple_ptr_nocopylERATcLcLDBTablegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBTable>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void simple_ptr_nocopylERATcLcLDBLinkgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void simple_ptr_nocopylERATcLcLDBLinkgR_Dictionary();
   static void *new_simple_ptr_nocopylERATcLcLDBLinkgR(void *p = 0);
   static void *newArray_simple_ptr_nocopylERATcLcLDBLinkgR(Long_t size, void *p);
   static void delete_simple_ptr_nocopylERATcLcLDBLinkgR(void *p);
   static void deleteArray_simple_ptr_nocopylERATcLcLDBLinkgR(void *p);
   static void destruct_simple_ptr_nocopylERATcLcLDBLinkgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::simple_ptr_nocopy<RAT::DBLink>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::simple_ptr_nocopy<RAT::DBLink>) == sizeof( ::ROOTShadow::Shadow::simple_ptr_nocopylERATcLcLDBLinkgR));
      ::simple_ptr_nocopy<RAT::DBLink> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::simple_ptr_nocopy<RAT::DBLink>),0);
      static ::ROOT::TGenericClassInfo 
         instance("simple_ptr_nocopy<RAT::DBLink>", "include/external/stlplus/smart_ptr.hpp", 354,
                  typeid(::simple_ptr_nocopy<RAT::DBLink>), ::ROOT::DefineBehavior(ptr, ptr),
                  &simple_ptr_nocopylERATcLcLDBLinkgR_ShowMembers, &simple_ptr_nocopylERATcLcLDBLinkgR_Dictionary, isa_proxy, 4,
                  sizeof(::simple_ptr_nocopy<RAT::DBLink>) );
      instance.SetNew(&new_simple_ptr_nocopylERATcLcLDBLinkgR);
      instance.SetNewArray(&newArray_simple_ptr_nocopylERATcLcLDBLinkgR);
      instance.SetDelete(&delete_simple_ptr_nocopylERATcLcLDBLinkgR);
      instance.SetDeleteArray(&deleteArray_simple_ptr_nocopylERATcLcLDBLinkgR);
      instance.SetDestructor(&destruct_simple_ptr_nocopylERATcLcLDBLinkgR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::simple_ptr_nocopy<RAT::DBLink>*)
   {
      return GenerateInitInstanceLocal((::simple_ptr_nocopy<RAT::DBLink>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBLink>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void simple_ptr_nocopylERATcLcLDBLinkgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBLink>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLGroupVelocity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLGroupVelocity(void *p = 0);
   static void *newArray_RATcLcLDUcLcLGroupVelocity(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLGroupVelocity(void *p);
   static void deleteArray_RATcLcLDUcLcLGroupVelocity(void *p);
   static void destruct_RATcLcLDUcLcLGroupVelocity(void *p);
   static void streamer_RATcLcLDUcLcLGroupVelocity(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::GroupVelocity*)
   {
      ::RAT::DU::GroupVelocity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::GroupVelocity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::GroupVelocity", ::RAT::DU::GroupVelocity::Class_Version(), "include/RAT/DU/GroupVelocity.hh", 34,
                  typeid(::RAT::DU::GroupVelocity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::GroupVelocity::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::GroupVelocity) );
      instance.SetNew(&new_RATcLcLDUcLcLGroupVelocity);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLGroupVelocity);
      instance.SetDelete(&delete_RATcLcLDUcLcLGroupVelocity);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLGroupVelocity);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLGroupVelocity);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLGroupVelocity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::GroupVelocity*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::GroupVelocity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLLightPathCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLLightPathCalculator(void *p = 0);
   static void *newArray_RATcLcLDUcLcLLightPathCalculator(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLLightPathCalculator(void *p);
   static void deleteArray_RATcLcLDUcLcLLightPathCalculator(void *p);
   static void destruct_RATcLcLDUcLcLLightPathCalculator(void *p);
   static void streamer_RATcLcLDUcLcLLightPathCalculator(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::LightPathCalculator*)
   {
      ::RAT::DU::LightPathCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::LightPathCalculator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::LightPathCalculator", ::RAT::DU::LightPathCalculator::Class_Version(), "include/RAT/DU/LightPathCalculator.hh", 69,
                  typeid(::RAT::DU::LightPathCalculator), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::LightPathCalculator::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::LightPathCalculator) );
      instance.SetNew(&new_RATcLcLDUcLcLLightPathCalculator);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLLightPathCalculator);
      instance.SetDelete(&delete_RATcLcLDUcLcLLightPathCalculator);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLLightPathCalculator);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLLightPathCalculator);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLLightPathCalculator);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::LightPathCalculator*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::LightPathCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLPanelInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLPanelInfo(void *p = 0);
   static void *newArray_RATcLcLDUcLcLPanelInfo(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLPanelInfo(void *p);
   static void deleteArray_RATcLcLDUcLcLPanelInfo(void *p);
   static void destruct_RATcLcLDUcLcLPanelInfo(void *p);
   static void streamer_RATcLcLDUcLcLPanelInfo(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PanelInfo*)
   {
      ::RAT::DU::PanelInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PanelInfo >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::PanelInfo", ::RAT::DU::PanelInfo::Class_Version(), "include/RAT/DU/PanelInfo.hh", 46,
                  typeid(::RAT::DU::PanelInfo), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::PanelInfo::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::PanelInfo) );
      instance.SetNew(&new_RATcLcLDUcLcLPanelInfo);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLPanelInfo);
      instance.SetDelete(&delete_RATcLcLDUcLcLPanelInfo);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPanelInfo);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLPanelInfo);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPanelInfo);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PanelInfo*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::PanelInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLChanHWStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLChanHWStatus(void *p = 0);
   static void *newArray_RATcLcLDUcLcLChanHWStatus(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLChanHWStatus(void *p);
   static void deleteArray_RATcLcLDUcLcLChanHWStatus(void *p);
   static void destruct_RATcLcLDUcLcLChanHWStatus(void *p);
   static void streamer_RATcLcLDUcLcLChanHWStatus(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ChanHWStatus*)
   {
      ::RAT::DU::ChanHWStatus *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::ChanHWStatus >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ChanHWStatus", ::RAT::DU::ChanHWStatus::Class_Version(), "include/RAT/DU/ChanHWStatus.hh", 41,
                  typeid(::RAT::DU::ChanHWStatus), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::ChanHWStatus::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::ChanHWStatus) );
      instance.SetNew(&new_RATcLcLDUcLcLChanHWStatus);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLChanHWStatus);
      instance.SetDelete(&delete_RATcLcLDUcLcLChanHWStatus);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLChanHWStatus);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLChanHWStatus);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLChanHWStatus);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ChanHWStatus*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ChanHWStatus*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLPMTCalStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLPMTCalStatus(void *p = 0);
   static void *newArray_RATcLcLDUcLcLPMTCalStatus(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLPMTCalStatus(void *p);
   static void deleteArray_RATcLcLDUcLcLPMTCalStatus(void *p);
   static void destruct_RATcLcLDUcLcLPMTCalStatus(void *p);
   static void streamer_RATcLcLDUcLcLPMTCalStatus(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::PMTCalStatus*)
   {
      ::RAT::DU::PMTCalStatus *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::PMTCalStatus >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::PMTCalStatus", ::RAT::DU::PMTCalStatus::Class_Version(), "include/RAT/DU/PMTCalStatus.hh", 33,
                  typeid(::RAT::DU::PMTCalStatus), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::PMTCalStatus::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::PMTCalStatus) );
      instance.SetNew(&new_RATcLcLDUcLcLPMTCalStatus);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLPMTCalStatus);
      instance.SetDelete(&delete_RATcLcLDUcLcLPMTCalStatus);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPMTCalStatus);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLPMTCalStatus);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPMTCalStatus);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::PMTCalStatus*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::PMTCalStatus*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLReactorNuOsc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDUcLcLReactorNuOsc_Dictionary();
   static void *new_RATcLcLDUcLcLReactorNuOsc(void *p = 0);
   static void *newArray_RATcLcLDUcLcLReactorNuOsc(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLReactorNuOsc(void *p);
   static void deleteArray_RATcLcLDUcLcLReactorNuOsc(void *p);
   static void destruct_RATcLcLDUcLcLReactorNuOsc(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReactorNuOsc*)
   {
      ::RAT::DU::ReactorNuOsc *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReactorNuOsc),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ReactorNuOsc", "include/RAT/DU/ReactorNuOsc.hh", 37,
                  typeid(::RAT::DU::ReactorNuOsc), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RATcLcLDUcLcLReactorNuOsc_Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::ReactorNuOsc) );
      instance.SetNew(&new_RATcLcLDUcLcLReactorNuOsc);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLReactorNuOsc);
      instance.SetDelete(&delete_RATcLcLDUcLcLReactorNuOsc);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReactorNuOsc);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLReactorNuOsc);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReactorNuOsc*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ReactorNuOsc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ReactorNuOsc*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDUcLcLReactorNuOsc_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ReactorNuOsc*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLShadowingCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDUcLcLShadowingCalculator_Dictionary();
   static void *new_RATcLcLDUcLcLShadowingCalculator(void *p = 0);
   static void *newArray_RATcLcLDUcLcLShadowingCalculator(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLShadowingCalculator(void *p);
   static void deleteArray_RATcLcLDUcLcLShadowingCalculator(void *p);
   static void destruct_RATcLcLDUcLcLShadowingCalculator(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ShadowingCalculator*)
   {
      ::RAT::DU::ShadowingCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ShadowingCalculator),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ShadowingCalculator", "include/RAT/DU/ShadowingCalculator.hh", 56,
                  typeid(::RAT::DU::ShadowingCalculator), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RATcLcLDUcLcLShadowingCalculator_Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::ShadowingCalculator) );
      instance.SetNew(&new_RATcLcLDUcLcLShadowingCalculator);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLShadowingCalculator);
      instance.SetDelete(&delete_RATcLcLDUcLcLShadowingCalculator);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLShadowingCalculator);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLShadowingCalculator);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ShadowingCalculator*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ShadowingCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ShadowingCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDUcLcLShadowingCalculator_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ShadowingCalculator*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLSegmentor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLSegmentor(void *p = 0);
   static void *newArray_RATcLcLDUcLcLSegmentor(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLSegmentor(void *p);
   static void deleteArray_RATcLcLDUcLcLSegmentor(void *p);
   static void destruct_RATcLcLDUcLcLSegmentor(void *p);
   static void streamer_RATcLcLDUcLcLSegmentor(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Segmentor*)
   {
      ::RAT::DU::Segmentor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Segmentor >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::Segmentor", ::RAT::DU::Segmentor::Class_Version(), "include/RAT/DU/Segmentor.hh", 45,
                  typeid(::RAT::DU::Segmentor), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::Segmentor::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::Segmentor) );
      instance.SetNew(&new_RATcLcLDUcLcLSegmentor);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLSegmentor);
      instance.SetDelete(&delete_RATcLcLDUcLcLSegmentor);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLSegmentor);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLSegmentor);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLSegmentor);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Segmentor*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::Segmentor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLSOCReader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RATcLcLDUcLcLSOCReader(void *p);
   static void deleteArray_RATcLcLDUcLcLSOCReader(void *p);
   static void destruct_RATcLcLDUcLcLSOCReader(void *p);
   static void streamer_RATcLcLDUcLcLSOCReader(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::SOCReader*)
   {
      ::RAT::DU::SOCReader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::SOCReader >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::SOCReader", ::RAT::DU::SOCReader::Class_Version(), "include/RAT/DU/SOCReader.hh", 47,
                  typeid(::RAT::DU::SOCReader), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::SOCReader::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::SOCReader) );
      instance.SetDelete(&delete_RATcLcLDUcLcLSOCReader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLSOCReader);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLSOCReader);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLSOCReader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::SOCReader*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::SOCReader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLReconCorrector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDUcLcLReconCorrector_Dictionary();
   static void *new_RATcLcLDUcLcLReconCorrector(void *p = 0);
   static void *newArray_RATcLcLDUcLcLReconCorrector(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLReconCorrector(void *p);
   static void deleteArray_RATcLcLDUcLcLReconCorrector(void *p);
   static void destruct_RATcLcLDUcLcLReconCorrector(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReconCorrector*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DU::ReconCorrector) == sizeof( ::ROOTShadow::Shadow::RAT::DU::ReconCorrector));
      ::RAT::DU::ReconCorrector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReconCorrector),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ReconCorrector", "include/RAT/DU/ReconCorrector.hh", 32,
                  typeid(::RAT::DU::ReconCorrector), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDUcLcLReconCorrector_ShowMembers, &RATcLcLDUcLcLReconCorrector_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DU::ReconCorrector) );
      instance.SetNew(&new_RATcLcLDUcLcLReconCorrector);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLReconCorrector);
      instance.SetDelete(&delete_RATcLcLDUcLcLReconCorrector);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReconCorrector);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLReconCorrector);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReconCorrector*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ReconCorrector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ReconCorrector*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDUcLcLReconCorrector_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ReconCorrector*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLReconCalibrator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDUcLcLReconCalibrator_Dictionary();
   static void *new_RATcLcLDUcLcLReconCalibrator(void *p = 0);
   static void *newArray_RATcLcLDUcLcLReconCalibrator(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLReconCalibrator(void *p);
   static void deleteArray_RATcLcLDUcLcLReconCalibrator(void *p);
   static void destruct_RATcLcLDUcLcLReconCalibrator(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::ReconCalibrator*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DU::ReconCalibrator) == sizeof( ::ROOTShadow::Shadow::RAT::DU::ReconCalibrator));
      ::RAT::DU::ReconCalibrator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DU::ReconCalibrator),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::ReconCalibrator", "include/RAT/DU/ReconCalibrator.hh", 37,
                  typeid(::RAT::DU::ReconCalibrator), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDUcLcLReconCalibrator_ShowMembers, &RATcLcLDUcLcLReconCalibrator_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DU::ReconCalibrator) );
      instance.SetNew(&new_RATcLcLDUcLcLReconCalibrator);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLReconCalibrator);
      instance.SetDelete(&delete_RATcLcLDUcLcLReconCalibrator);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLReconCalibrator);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLReconCalibrator);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::ReconCalibrator*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::ReconCalibrator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::ReconCalibrator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDUcLcLReconCalibrator_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ReconCalibrator*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLFitterPMT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLFitterPMT_Dictionary();
   static void *new_RATcLcLFitterPMT(void *p = 0);
   static void *newArray_RATcLcLFitterPMT(Long_t size, void *p);
   static void delete_RATcLcLFitterPMT(void *p);
   static void deleteArray_RATcLcLFitterPMT(void *p);
   static void destruct_RATcLcLFitterPMT(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::FitterPMT*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::FitterPMT) == sizeof( ::ROOTShadow::Shadow::RAT::FitterPMT));
      ::RAT::FitterPMT *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::FitterPMT),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::FitterPMT", "include/RAT/FitterPMT.hh", 36,
                  typeid(::RAT::FitterPMT), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLFitterPMT_ShowMembers, &RATcLcLFitterPMT_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::FitterPMT) );
      instance.SetNew(&new_RATcLcLFitterPMT);
      instance.SetNewArray(&newArray_RATcLcLFitterPMT);
      instance.SetDelete(&delete_RATcLcLFitterPMT);
      instance.SetDeleteArray(&deleteArray_RATcLcLFitterPMT);
      instance.SetDestructor(&destruct_RATcLcLFitterPMT);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::FitterPMT*)
   {
      return GenerateInitInstanceLocal((::RAT::FitterPMT*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::FitterPMT*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLFitterPMT_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::FitterPMT*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLTimeResidualCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLTimeResidualCalculator(void *p = 0);
   static void *newArray_RATcLcLDUcLcLTimeResidualCalculator(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLTimeResidualCalculator(void *p);
   static void deleteArray_RATcLcLDUcLcLTimeResidualCalculator(void *p);
   static void destruct_RATcLcLDUcLcLTimeResidualCalculator(void *p);
   static void streamer_RATcLcLDUcLcLTimeResidualCalculator(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::TimeResidualCalculator*)
   {
      ::RAT::DU::TimeResidualCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::TimeResidualCalculator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::TimeResidualCalculator", ::RAT::DU::TimeResidualCalculator::Class_Version(), "include/RAT/DU/TimeResidualCalculator.hh", 36,
                  typeid(::RAT::DU::TimeResidualCalculator), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::TimeResidualCalculator::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::TimeResidualCalculator) );
      instance.SetNew(&new_RATcLcLDUcLcLTimeResidualCalculator);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLTimeResidualCalculator);
      instance.SetDelete(&delete_RATcLcLDUcLcLTimeResidualCalculator);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLTimeResidualCalculator);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLTimeResidualCalculator);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLTimeResidualCalculator);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::TimeResidualCalculator*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::TimeResidualCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLUtility_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLUtility(void *p = 0);
   static void delete_RATcLcLDUcLcLUtility(void *p);
   static void deleteArray_RATcLcLDUcLcLUtility(void *p);
   static void destruct_RATcLcLDUcLcLUtility(void *p);
   static void streamer_RATcLcLDUcLcLUtility(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Utility*)
   {
      ::RAT::DU::Utility *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Utility >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::Utility", ::RAT::DU::Utility::Class_Version(), "include/RAT/DU/Utility.hh", 64,
                  typeid(::RAT::DU::Utility), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::Utility::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::Utility) );
      instance.SetNew(&new_RATcLcLDUcLcLUtility);
      instance.SetDelete(&delete_RATcLcLDUcLcLUtility);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLUtility);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLUtility);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLUtility);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Utility*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::Utility*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::Utility*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLTrackNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLTrackNode(void *p = 0);
   static void *newArray_RATcLcLTrackNode(Long_t size, void *p);
   static void delete_RATcLcLTrackNode(void *p);
   static void deleteArray_RATcLcLTrackNode(void *p);
   static void destruct_RATcLcLTrackNode(void *p);
   static void streamer_RATcLcLTrackNode(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackNode*)
   {
      ::RAT::TrackNode *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::TrackNode >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::TrackNode", ::RAT::TrackNode::Class_Version(), "include/RAT/TrackNode.hh", 11,
                  typeid(::RAT::TrackNode), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::TrackNode::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::TrackNode) );
      instance.SetNew(&new_RATcLcLTrackNode);
      instance.SetNewArray(&newArray_RATcLcLTrackNode);
      instance.SetDelete(&delete_RATcLcLTrackNode);
      instance.SetDeleteArray(&deleteArray_RATcLcLTrackNode);
      instance.SetDestructor(&destruct_RATcLcLTrackNode);
      instance.SetStreamerFunc(&streamer_RATcLcLTrackNode);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackNode*)
   {
      return GenerateInitInstanceLocal((::RAT::TrackNode*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::TrackNode*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLTrackCursor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLTrackCursor_Dictionary();
   static void delete_RATcLcLTrackCursor(void *p);
   static void deleteArray_RATcLcLTrackCursor(void *p);
   static void destruct_RATcLcLTrackCursor(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackCursor*)
   {
      ::RAT::TrackCursor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::TrackCursor),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::TrackCursor", "include/RAT/TrackCursor.hh", 17,
                  typeid(::RAT::TrackCursor), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RATcLcLTrackCursor_Dictionary, isa_proxy, 0,
                  sizeof(::RAT::TrackCursor) );
      instance.SetDelete(&delete_RATcLcLTrackCursor);
      instance.SetDeleteArray(&deleteArray_RATcLcLTrackCursor);
      instance.SetDestructor(&destruct_RATcLcLTrackCursor);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackCursor*)
   {
      return GenerateInitInstanceLocal((::RAT::TrackCursor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::TrackCursor*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLTrackCursor_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackCursor*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLTrackNav_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLTrackNav_Dictionary();
   static void delete_RATcLcLTrackNav(void *p);
   static void deleteArray_RATcLcLTrackNav(void *p);
   static void destruct_RATcLcLTrackNav(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::TrackNav*)
   {
      ::RAT::TrackNav *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::TrackNav),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::TrackNav", "include/RAT/TrackNav.hh", 15,
                  typeid(::RAT::TrackNav), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RATcLcLTrackNav_Dictionary, isa_proxy, 0,
                  sizeof(::RAT::TrackNav) );
      instance.SetDelete(&delete_RATcLcLTrackNav);
      instance.SetDeleteArray(&deleteArray_RATcLcLTrackNav);
      instance.SetDestructor(&destruct_RATcLcLTrackNav);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::TrackNav*)
   {
      return GenerateInitInstanceLocal((::RAT::TrackNav*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::TrackNav*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLTrackNav_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackNav*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDBCommandLoader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDBCommandLoader_Dictionary();
   static void *new_RATcLcLDBCommandLoader(void *p = 0);
   static void *newArray_RATcLcLDBCommandLoader(Long_t size, void *p);
   static void delete_RATcLcLDBCommandLoader(void *p);
   static void deleteArray_RATcLcLDBCommandLoader(void *p);
   static void destruct_RATcLcLDBCommandLoader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBCommandLoader*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DBCommandLoader) == sizeof( ::ROOTShadow::Shadow::RAT::DBCommandLoader));
      ::RAT::DBCommandLoader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBCommandLoader),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DBCommandLoader", "include/RAT/DBCommandLoader.hh", 29,
                  typeid(::RAT::DBCommandLoader), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDBCommandLoader_ShowMembers, &RATcLcLDBCommandLoader_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DBCommandLoader) );
      instance.SetNew(&new_RATcLcLDBCommandLoader);
      instance.SetNewArray(&newArray_RATcLcLDBCommandLoader);
      instance.SetDelete(&delete_RATcLcLDBCommandLoader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDBCommandLoader);
      instance.SetDestructor(&destruct_RATcLcLDBCommandLoader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DBCommandLoader*)
   {
      return GenerateInitInstanceLocal((::RAT::DBCommandLoader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DBCommandLoader*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDBCommandLoader_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBCommandLoader*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDBTextLoader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDBTextLoader_Dictionary();
   static void *new_RATcLcLDBTextLoader(void *p = 0);
   static void *newArray_RATcLcLDBTextLoader(Long_t size, void *p);
   static void delete_RATcLcLDBTextLoader(void *p);
   static void deleteArray_RATcLcLDBTextLoader(void *p);
   static void destruct_RATcLcLDBTextLoader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBTextLoader*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DBTextLoader) == sizeof( ::ROOTShadow::Shadow::RAT::DBTextLoader));
      ::RAT::DBTextLoader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBTextLoader),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DBTextLoader", "include/RAT/DBTextLoader.hh", 109,
                  typeid(::RAT::DBTextLoader), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDBTextLoader_ShowMembers, &RATcLcLDBTextLoader_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DBTextLoader) );
      instance.SetNew(&new_RATcLcLDBTextLoader);
      instance.SetNewArray(&newArray_RATcLcLDBTextLoader);
      instance.SetDelete(&delete_RATcLcLDBTextLoader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDBTextLoader);
      instance.SetDestructor(&destruct_RATcLcLDBTextLoader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DBTextLoader*)
   {
      return GenerateInitInstanceLocal((::RAT::DBTextLoader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DBTextLoader*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDBTextLoader_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBTextLoader*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDBJsonLoader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLDBJsonLoader_Dictionary();
   static void *new_RATcLcLDBJsonLoader(void *p = 0);
   static void *newArray_RATcLcLDBJsonLoader(Long_t size, void *p);
   static void delete_RATcLcLDBJsonLoader(void *p);
   static void deleteArray_RATcLcLDBJsonLoader(void *p);
   static void destruct_RATcLcLDBJsonLoader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DBJsonLoader*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::DBJsonLoader) == sizeof( ::ROOTShadow::Shadow::RAT::DBJsonLoader));
      ::RAT::DBJsonLoader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::DBJsonLoader),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DBJsonLoader", "include/RAT/DBJsonLoader.hh", 17,
                  typeid(::RAT::DBJsonLoader), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLDBJsonLoader_ShowMembers, &RATcLcLDBJsonLoader_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DBJsonLoader) );
      instance.SetNew(&new_RATcLcLDBJsonLoader);
      instance.SetNewArray(&newArray_RATcLcLDBJsonLoader);
      instance.SetDelete(&delete_RATcLcLDBJsonLoader);
      instance.SetDeleteArray(&deleteArray_RATcLcLDBJsonLoader);
      instance.SetDestructor(&destruct_RATcLcLDBJsonLoader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DBJsonLoader*)
   {
      return GenerateInitInstanceLocal((::RAT::DBJsonLoader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DBJsonLoader*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLDBJsonLoader_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBJsonLoader*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLHTTPDownloader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLHTTPDownloader_Dictionary();
   static void *new_RATcLcLHTTPDownloader(void *p = 0);
   static void *newArray_RATcLcLHTTPDownloader(Long_t size, void *p);
   static void delete_RATcLcLHTTPDownloader(void *p);
   static void deleteArray_RATcLcLHTTPDownloader(void *p);
   static void destruct_RATcLcLHTTPDownloader(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::HTTPDownloader*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::HTTPDownloader) == sizeof( ::ROOTShadow::Shadow::RAT::HTTPDownloader));
      ::RAT::HTTPDownloader *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::HTTPDownloader),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::HTTPDownloader", "include/RAT/HTTPDownloader.hh", 21,
                  typeid(::RAT::HTTPDownloader), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLHTTPDownloader_ShowMembers, &RATcLcLHTTPDownloader_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::HTTPDownloader) );
      instance.SetNew(&new_RATcLcLHTTPDownloader);
      instance.SetNewArray(&newArray_RATcLcLHTTPDownloader);
      instance.SetDelete(&delete_RATcLcLHTTPDownloader);
      instance.SetDeleteArray(&deleteArray_RATcLcLHTTPDownloader);
      instance.SetDestructor(&destruct_RATcLcLHTTPDownloader);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::HTTPDownloader*)
   {
      return GenerateInitInstanceLocal((::RAT::HTTPDownloader*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::HTTPDownloader*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLHTTPDownloader_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::HTTPDownloader*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLMetaInformation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLMetaInformation_Dictionary();
   static void *new_RATcLcLMetaInformation(void *p = 0);
   static void delete_RATcLcLMetaInformation(void *p);
   static void deleteArray_RATcLcLMetaInformation(void *p);
   static void destruct_RATcLcLMetaInformation(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::MetaInformation*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::MetaInformation) == sizeof( ::ROOTShadow::Shadow::RAT::MetaInformation));
      ::RAT::MetaInformation *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::MetaInformation),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::MetaInformation", "include/RAT/MetaInformation.hh", 38,
                  typeid(::RAT::MetaInformation), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLMetaInformation_ShowMembers, &RATcLcLMetaInformation_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::MetaInformation) );
      instance.SetNew(&new_RATcLcLMetaInformation);
      instance.SetDelete(&delete_RATcLcLMetaInformation);
      instance.SetDeleteArray(&deleteArray_RATcLcLMetaInformation);
      instance.SetDestructor(&destruct_RATcLcLMetaInformation);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::MetaInformation*)
   {
      return GenerateInitInstanceLocal((::RAT::MetaInformation*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::MetaInformation*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLMetaInformation_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::MetaInformation*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void PmtEventRecord_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void PmtEventRecord_Dictionary();
   static void *new_PmtEventRecord(void *p = 0);
   static void *newArray_PmtEventRecord(Long_t size, void *p);
   static void delete_PmtEventRecord(void *p);
   static void deleteArray_PmtEventRecord(void *p);
   static void destruct_PmtEventRecord(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::PmtEventRecord*)
   {
      ::PmtEventRecord *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PmtEventRecord),0);
      static ::ROOT::TGenericClassInfo 
         instance("PmtEventRecord", "include/RAT/Record_Info.hh", 795,
                  typeid(::PmtEventRecord), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &PmtEventRecord_Dictionary, isa_proxy, 2,
                  sizeof(::PmtEventRecord) );
      instance.SetNew(&new_PmtEventRecord);
      instance.SetNewArray(&newArray_PmtEventRecord);
      instance.SetDelete(&delete_PmtEventRecord);
      instance.SetDeleteArray(&deleteArray_PmtEventRecord);
      instance.SetDestructor(&destruct_PmtEventRecord);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::PmtEventRecord*)
   {
      return GenerateInitInstanceLocal((::PmtEventRecord*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::PmtEventRecord*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void PmtEventRecord_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::PmtEventRecord*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RunRecord_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RunRecord_Dictionary();
   static void *new_RunRecord(void *p = 0);
   static void *newArray_RunRecord(Long_t size, void *p);
   static void delete_RunRecord(void *p);
   static void deleteArray_RunRecord(void *p);
   static void destruct_RunRecord(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RunRecord*)
   {
      ::RunRecord *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RunRecord),0);
      static ::ROOT::TGenericClassInfo 
         instance("RunRecord", "include/RAT/Record_Info.hh", 150,
                  typeid(::RunRecord), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &RunRecord_Dictionary, isa_proxy, 2,
                  sizeof(::RunRecord) );
      instance.SetNew(&new_RunRecord);
      instance.SetNewArray(&newArray_RunRecord);
      instance.SetDelete(&delete_RunRecord);
      instance.SetDeleteArray(&deleteArray_RunRecord);
      instance.SetDestructor(&destruct_RunRecord);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RunRecord*)
   {
      return GenerateInitInstanceLocal((::RunRecord*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RunRecord*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RunRecord_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RunRecord*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TriggerInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TriggerInfo_Dictionary();
   static void *new_TriggerInfo(void *p = 0);
   static void *newArray_TriggerInfo(Long_t size, void *p);
   static void delete_TriggerInfo(void *p);
   static void deleteArray_TriggerInfo(void *p);
   static void destruct_TriggerInfo(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggerInfo*)
   {
      ::TriggerInfo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TriggerInfo),0);
      static ::ROOT::TGenericClassInfo 
         instance("TriggerInfo", "include/RAT/Record_Info.hh", 233,
                  typeid(::TriggerInfo), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &TriggerInfo_Dictionary, isa_proxy, 2,
                  sizeof(::TriggerInfo) );
      instance.SetNew(&new_TriggerInfo);
      instance.SetNewArray(&newArray_TriggerInfo);
      instance.SetDelete(&delete_TriggerInfo);
      instance.SetDeleteArray(&deleteArray_TriggerInfo);
      instance.SetDestructor(&destruct_TriggerInfo);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TriggerInfo*)
   {
      return GenerateInitInstanceLocal((::TriggerInfo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TriggerInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TriggerInfo_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TriggerInfo*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void EpedRecord_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void EpedRecord_Dictionary();
   static void *new_EpedRecord(void *p = 0);
   static void *newArray_EpedRecord(Long_t size, void *p);
   static void delete_EpedRecord(void *p);
   static void deleteArray_EpedRecord(void *p);
   static void destruct_EpedRecord(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::EpedRecord*)
   {
      ::EpedRecord *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::EpedRecord),0);
      static ::ROOT::TGenericClassInfo 
         instance("EpedRecord", "include/RAT/Record_Info.hh", 278,
                  typeid(::EpedRecord), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &EpedRecord_Dictionary, isa_proxy, 2,
                  sizeof(::EpedRecord) );
      instance.SetNew(&new_EpedRecord);
      instance.SetNewArray(&newArray_EpedRecord);
      instance.SetDelete(&delete_EpedRecord);
      instance.SetDeleteArray(&deleteArray_EpedRecord);
      instance.SetDestructor(&destruct_EpedRecord);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::EpedRecord*)
   {
      return GenerateInitInstanceLocal((::EpedRecord*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EpedRecord*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void EpedRecord_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::EpedRecord*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ratzdab {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void ratzdab_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("ratzdab", 0 /*version*/, "include/RAT/Record_Info.hh", 862,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &ratzdab_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void ratzdab_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ratzdab {
namespace unpack {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void ratzdabcLcLunpack_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("ratzdab::unpack", 0 /*version*/, "include/RAT/zdab_convert.hh", 58,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &ratzdabcLcLunpack_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void ratzdabcLcLunpack_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}
}

namespace ratzdab {
namespace pack {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void ratzdabcLcLpack_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("ratzdab::pack", 0 /*version*/, "include/RAT/zdab_convert.hh", 75,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &ratzdabcLcLpack_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void ratzdabcLcLpack_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}
}

namespace ROOTDict {
   void ratzdabcLcLunknown_record_error_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ratzdabcLcLunknown_record_error_Dictionary();
   static void *new_ratzdabcLcLunknown_record_error(void *p = 0);
   static void *newArray_ratzdabcLcLunknown_record_error(Long_t size, void *p);
   static void delete_ratzdabcLcLunknown_record_error(void *p);
   static void deleteArray_ratzdabcLcLunknown_record_error(void *p);
   static void destruct_ratzdabcLcLunknown_record_error(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::unknown_record_error*)
   {
      ::ratzdab::unknown_record_error *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::unknown_record_error),0);
      static ::ROOT::TGenericClassInfo 
         instance("ratzdab::unknown_record_error", "include/RAT/zdab_convert.hh", 92,
                  typeid(::ratzdab::unknown_record_error), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &ratzdabcLcLunknown_record_error_Dictionary, isa_proxy, 2,
                  sizeof(::ratzdab::unknown_record_error) );
      instance.SetNew(&new_ratzdabcLcLunknown_record_error);
      instance.SetNewArray(&newArray_ratzdabcLcLunknown_record_error);
      instance.SetDelete(&delete_ratzdabcLcLunknown_record_error);
      instance.SetDeleteArray(&deleteArray_ratzdabcLcLunknown_record_error);
      instance.SetDestructor(&destruct_ratzdabcLcLunknown_record_error);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ratzdab::unknown_record_error*)
   {
      return GenerateInitInstanceLocal((::ratzdab::unknown_record_error*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ratzdab::unknown_record_error*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ratzdabcLcLunknown_record_error_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ratzdab::unknown_record_error*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void PZdabFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void PZdabFile_Dictionary();
   static void *new_PZdabFile(void *p = 0);
   static void *newArray_PZdabFile(Long_t size, void *p);
   static void delete_PZdabFile(void *p);
   static void deleteArray_PZdabFile(void *p);
   static void destruct_PZdabFile(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::PZdabFile*)
   {
      ::PZdabFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::PZdabFile),0);
      static ::ROOT::TGenericClassInfo 
         instance("PZdabFile", "include/RAT/PZdabFile.hh", 154,
                  typeid(::PZdabFile), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &PZdabFile_Dictionary, isa_proxy, 0,
                  sizeof(::PZdabFile) );
      instance.SetNew(&new_PZdabFile);
      instance.SetNewArray(&newArray_PZdabFile);
      instance.SetDelete(&delete_PZdabFile);
      instance.SetDeleteArray(&deleteArray_PZdabFile);
      instance.SetDestructor(&destruct_PZdabFile);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::PZdabFile*)
   {
      return GenerateInitInstanceLocal((::PZdabFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::PZdabFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void PZdabFile_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::PZdabFile*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ratzdabcLcLzdabfile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ratzdabcLcLzdabfile_Dictionary();
   static void delete_ratzdabcLcLzdabfile(void *p);
   static void deleteArray_ratzdabcLcLzdabfile(void *p);
   static void destruct_ratzdabcLcLzdabfile(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::zdabfile*)
   {
      ::ratzdab::zdabfile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::zdabfile),0);
      static ::ROOT::TGenericClassInfo 
         instance("ratzdab::zdabfile", "include/RAT/zdab_file.hh", 24,
                  typeid(::ratzdab::zdabfile), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &ratzdabcLcLzdabfile_Dictionary, isa_proxy, 2,
                  sizeof(::ratzdab::zdabfile) );
      instance.SetDelete(&delete_ratzdabcLcLzdabfile);
      instance.SetDeleteArray(&deleteArray_ratzdabcLcLzdabfile);
      instance.SetDestructor(&destruct_ratzdabcLcLzdabfile);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ratzdab::zdabfile*)
   {
      return GenerateInitInstanceLocal((::ratzdab::zdabfile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ratzdab::zdabfile*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ratzdabcLcLzdabfile_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ratzdab::zdabfile*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ratzdabcLcLzdabfilecLcLzdab_file_read_error_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary();
   static void *new_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p = 0);
   static void *newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(Long_t size, void *p);
   static void delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p);
   static void deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p);
   static void destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ratzdab::zdabfile::zdab_file_read_error*)
   {
      ::ratzdab::zdabfile::zdab_file_read_error *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ratzdab::zdabfile::zdab_file_read_error),0);
      static ::ROOT::TGenericClassInfo 
         instance("ratzdab::zdabfile::zdab_file_read_error", "include/RAT/zdab_file.hh", 41,
                  typeid(::ratzdab::zdabfile::zdab_file_read_error), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary, isa_proxy, 2,
                  sizeof(::ratzdab::zdabfile::zdab_file_read_error) );
      instance.SetNew(&new_ratzdabcLcLzdabfilecLcLzdab_file_read_error);
      instance.SetNewArray(&newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error);
      instance.SetDelete(&delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error);
      instance.SetDeleteArray(&deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error);
      instance.SetDestructor(&destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ratzdab::zdabfile::zdab_file_read_error*)
   {
      return GenerateInitInstanceLocal((::ratzdab::zdabfile::zdab_file_read_error*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ratzdab::zdabfile::zdab_file_read_error*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ratzdabcLcLzdabfilecLcLzdab_file_read_error_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ratzdab::zdabfile::zdab_file_read_error*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void ManipRopeStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ManipRopeStatus_Dictionary();
   static void *new_ManipRopeStatus(void *p = 0);
   static void *newArray_ManipRopeStatus(Long_t size, void *p);
   static void delete_ManipRopeStatus(void *p);
   static void deleteArray_ManipRopeStatus(void *p);
   static void destruct_ManipRopeStatus(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::ManipRopeStatus*)
   {
      ::ManipRopeStatus *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ManipRopeStatus),0);
      static ::ROOT::TGenericClassInfo 
         instance("ManipRopeStatus", "include/RAT/Record_Info.hh", 351,
                  typeid(::ManipRopeStatus), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &ManipRopeStatus_Dictionary, isa_proxy, 2,
                  sizeof(::ManipRopeStatus) );
      instance.SetNew(&new_ManipRopeStatus);
      instance.SetNewArray(&newArray_ManipRopeStatus);
      instance.SetDelete(&delete_ManipRopeStatus);
      instance.SetDeleteArray(&deleteArray_ManipRopeStatus);
      instance.SetDestructor(&destruct_ManipRopeStatus);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::ManipRopeStatus*)
   {
      return GenerateInitInstanceLocal((::ManipRopeStatus*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ManipRopeStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ManipRopeStatus_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::ManipRopeStatus*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void MTCReadoutData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void MTCReadoutData_Dictionary();
   static void *new_MTCReadoutData(void *p = 0);
   static void *newArray_MTCReadoutData(Long_t size, void *p);
   static void delete_MTCReadoutData(void *p);
   static void deleteArray_MTCReadoutData(void *p);
   static void destruct_MTCReadoutData(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::MTCReadoutData*)
   {
      ::MTCReadoutData *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MTCReadoutData),0);
      static ::ROOT::TGenericClassInfo 
         instance("MTCReadoutData", "include/RAT/Record_Info.hh", 679,
                  typeid(::MTCReadoutData), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &MTCReadoutData_Dictionary, isa_proxy, 2,
                  sizeof(::MTCReadoutData) );
      instance.SetNew(&new_MTCReadoutData);
      instance.SetNewArray(&newArray_MTCReadoutData);
      instance.SetDelete(&delete_MTCReadoutData);
      instance.SetDeleteArray(&deleteArray_MTCReadoutData);
      instance.SetDestructor(&destruct_MTCReadoutData);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::MTCReadoutData*)
   {
      return GenerateInitInstanceLocal((::MTCReadoutData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MTCReadoutData*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void MTCReadoutData_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::MTCReadoutData*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace RAT {
namespace util {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void RATcLcLutil_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("RAT::util", 0 /*version*/, "include/RAT/PhysicsUtil.hh", 13,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &RATcLcLutil_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void RATcLcLutil_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}
}

namespace ROOTDict {
   void RATcLcLDUcLcLEnergySystematics_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RATcLcLDUcLcLEnergySystematics(void *p);
   static void deleteArray_RATcLcLDUcLcLEnergySystematics(void *p);
   static void destruct_RATcLcLDUcLcLEnergySystematics(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::EnergySystematics*)
   {
      ::RAT::DU::EnergySystematics *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::EnergySystematics >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::EnergySystematics", ::RAT::DU::EnergySystematics::Class_Version(), "include/RAT/DU/EnergySystematics.hh", 23,
                  typeid(::RAT::DU::EnergySystematics), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::EnergySystematics::Dictionary, isa_proxy, 4,
                  sizeof(::RAT::DU::EnergySystematics) );
      instance.SetDelete(&delete_RATcLcLDUcLcLEnergySystematics);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLEnergySystematics);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLEnergySystematics);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::EnergySystematics*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::EnergySystematics*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLDUcLcLPoint3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RATcLcLDUcLcLPoint3D(void *p = 0);
   static void *newArray_RATcLcLDUcLcLPoint3D(Long_t size, void *p);
   static void delete_RATcLcLDUcLcLPoint3D(void *p);
   static void deleteArray_RATcLcLDUcLcLPoint3D(void *p);
   static void destruct_RATcLcLDUcLcLPoint3D(void *p);
   static void streamer_RATcLcLDUcLcLPoint3D(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::DU::Point3D*)
   {
      ::RAT::DU::Point3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RAT::DU::Point3D >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::DU::Point3D", ::RAT::DU::Point3D::Class_Version(), "include/RAT/DU/Point3D.hh", 28,
                  typeid(::RAT::DU::Point3D), ::ROOT::DefineBehavior(ptr, ptr),
                  &::RAT::DU::Point3D::Dictionary, isa_proxy, 0,
                  sizeof(::RAT::DU::Point3D) );
      instance.SetNew(&new_RATcLcLDUcLcLPoint3D);
      instance.SetNewArray(&newArray_RATcLcLDUcLcLPoint3D);
      instance.SetDelete(&delete_RATcLcLDUcLcLPoint3D);
      instance.SetDeleteArray(&deleteArray_RATcLcLDUcLcLPoint3D);
      instance.SetDestructor(&destruct_RATcLcLDUcLcLPoint3D);
      instance.SetStreamerFunc(&streamer_RATcLcLDUcLcLPoint3D);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::DU::Point3D*)
   {
      return GenerateInitInstanceLocal((::RAT::DU::Point3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLPcLcLLightPath_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLPcLcLLightPath_Dictionary();
   static void *new_RATcLcLLPcLcLLightPath(void *p = 0);
   static void *newArray_RATcLcLLPcLcLLightPath(Long_t size, void *p);
   static void delete_RATcLcLLPcLcLLightPath(void *p);
   static void deleteArray_RATcLcLLPcLcLLightPath(void *p);
   static void destruct_RATcLcLLPcLcLLightPath(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPath*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::LP::LightPath) == sizeof( ::ROOTShadow::Shadow::RAT::LP::LightPath));
      ::RAT::LP::LightPath *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPath),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::LP::LightPath", "include/RAT/LightPath.hh", 28,
                  typeid(::RAT::LP::LightPath), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLPcLcLLightPath_ShowMembers, &RATcLcLLPcLcLLightPath_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::LP::LightPath) );
      instance.SetNew(&new_RATcLcLLPcLcLLightPath);
      instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPath);
      instance.SetDelete(&delete_RATcLcLLPcLcLLightPath);
      instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPath);
      instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPath);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPath*)
   {
      return GenerateInitInstanceLocal((::RAT::LP::LightPath*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::LP::LightPath*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLPcLcLLightPath_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPath*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLPcLcLLightPathFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLPcLcLLightPathFitter_Dictionary();
   static void delete_RATcLcLLPcLcLLightPathFitter(void *p);
   static void deleteArray_RATcLcLLPcLcLLightPathFitter(void *p);
   static void destruct_RATcLcLLPcLcLLightPathFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathFitter*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::LP::LightPathFitter) == sizeof( ::ROOTShadow::Shadow::RAT::LP::LightPathFitter));
      ::RAT::LP::LightPathFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathFitter),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::LP::LightPathFitter", "include/RAT/LightPathFitter.hh", 19,
                  typeid(::RAT::LP::LightPathFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLPcLcLLightPathFitter_ShowMembers, &RATcLcLLPcLcLLightPathFitter_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::LP::LightPathFitter) );
      instance.SetDelete(&delete_RATcLcLLPcLcLLightPathFitter);
      instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathFitter);
      instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathFitter*)
   {
      return GenerateInitInstanceLocal((::RAT::LP::LightPathFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::LP::LightPathFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLPcLcLLightPathFitter_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathFitter*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLPcLcLLightPathStraightFitter_Dictionary();
   static void *new_RATcLcLLPcLcLLightPathStraightFitter(void *p = 0);
   static void *newArray_RATcLcLLPcLcLLightPathStraightFitter(Long_t size, void *p);
   static void delete_RATcLcLLPcLcLLightPathStraightFitter(void *p);
   static void deleteArray_RATcLcLLPcLcLLightPathStraightFitter(void *p);
   static void destruct_RATcLcLLPcLcLLightPathStraightFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightFitter*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::LP::LightPathStraightFitter) == sizeof( ::ROOTShadow::Shadow::RAT::LP::LightPathStraightFitter));
      ::RAT::LP::LightPathStraightFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightFitter),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::LP::LightPathStraightFitter", "include/RAT/LightPathStraightFitter.hh", 24,
                  typeid(::RAT::LP::LightPathStraightFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLPcLcLLightPathStraightFitter_ShowMembers, &RATcLcLLPcLcLLightPathStraightFitter_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::LP::LightPathStraightFitter) );
      instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightFitter);
      instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightFitter);
      instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightFitter);
      instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightFitter);
      instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightFitter*)
   {
      return GenerateInitInstanceLocal((::RAT::LP::LightPathStraightFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLPcLcLLightPathStraightFitter_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightFitter*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightScint_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLPcLcLLightPathStraightScint_Dictionary();
   static void *new_RATcLcLLPcLcLLightPathStraightScint(void *p = 0);
   static void *newArray_RATcLcLLPcLcLLightPathStraightScint(Long_t size, void *p);
   static void delete_RATcLcLLPcLcLLightPathStraightScint(void *p);
   static void deleteArray_RATcLcLLPcLcLLightPathStraightScint(void *p);
   static void destruct_RATcLcLLPcLcLLightPathStraightScint(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightScint*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::LP::LightPathStraightScint) == sizeof( ::ROOTShadow::Shadow::RAT::LP::LightPathStraightScint));
      ::RAT::LP::LightPathStraightScint *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightScint),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::LP::LightPathStraightScint", "include/RAT/LightPathStraightScint.hh", 26,
                  typeid(::RAT::LP::LightPathStraightScint), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLPcLcLLightPathStraightScint_ShowMembers, &RATcLcLLPcLcLLightPathStraightScint_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::LP::LightPathStraightScint) );
      instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightScint);
      instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightScint);
      instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightScint);
      instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightScint);
      instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightScint);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightScint*)
   {
      return GenerateInitInstanceLocal((::RAT::LP::LightPathStraightScint*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScint*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLPcLcLLightPathStraightScint_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScint*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightScintWater_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void RATcLcLLPcLcLLightPathStraightScintWater_Dictionary();
   static void *new_RATcLcLLPcLcLLightPathStraightScintWater(void *p = 0);
   static void *newArray_RATcLcLLPcLcLLightPathStraightScintWater(Long_t size, void *p);
   static void delete_RATcLcLLPcLcLLightPathStraightScintWater(void *p);
   static void deleteArray_RATcLcLLPcLcLLightPathStraightScintWater(void *p);
   static void destruct_RATcLcLLPcLcLLightPathStraightScintWater(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RAT::LP::LightPathStraightScintWater*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::RAT::LP::LightPathStraightScintWater) == sizeof( ::ROOTShadow::Shadow::RAT::LP::LightPathStraightScintWater));
      ::RAT::LP::LightPathStraightScintWater *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::RAT::LP::LightPathStraightScintWater),0);
      static ::ROOT::TGenericClassInfo 
         instance("RAT::LP::LightPathStraightScintWater", "include/RAT/LightPathStraightScintWater.hh", 25,
                  typeid(::RAT::LP::LightPathStraightScintWater), ::ROOT::DefineBehavior(ptr, ptr),
                  &RATcLcLLPcLcLLightPathStraightScintWater_ShowMembers, &RATcLcLLPcLcLLightPathStraightScintWater_Dictionary, isa_proxy, 4,
                  sizeof(::RAT::LP::LightPathStraightScintWater) );
      instance.SetNew(&new_RATcLcLLPcLcLLightPathStraightScintWater);
      instance.SetNewArray(&newArray_RATcLcLLPcLcLLightPathStraightScintWater);
      instance.SetDelete(&delete_RATcLcLLPcLcLLightPathStraightScintWater);
      instance.SetDeleteArray(&deleteArray_RATcLcLLPcLcLLightPathStraightScintWater);
      instance.SetDestructor(&destruct_RATcLcLLPcLcLLightPathStraightScintWater);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::RAT::LP::LightPathStraightScintWater*)
   {
      return GenerateInitInstanceLocal((::RAT::LP::LightPathStraightScintWater*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScintWater*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void RATcLcLLPcLcLLightPathStraightScintWater_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScintWater*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr BitMask::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *BitMask::Class_Name()
{
   return "RAT::DS::BitMask";
}

//______________________________________________________________________________
const char *BitMask::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int BitMask::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void BitMask::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *BitMask::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::BitMask*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr Calib::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Calib::Class_Name()
{
   return "RAT::DS::Calib";
}

//______________________________________________________________________________
const char *Calib::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Calib::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Calib::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Calib::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Calib*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr ClassifierResult::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ClassifierResult::Class_Name()
{
   return "RAT::DS::ClassifierResult";
}

//______________________________________________________________________________
const char *ClassifierResult::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ClassifierResult::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void ClassifierResult::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *ClassifierResult::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ClassifierResult*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr DataQCFlags::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DataQCFlags::Class_Name()
{
   return "RAT::DS::DataQCFlags";
}

//______________________________________________________________________________
const char *DataQCFlags::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DataQCFlags::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DataQCFlags::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DataQCFlags::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::DataQCFlags*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr Digitiser::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Digitiser::Class_Name()
{
   return "RAT::DS::Digitiser";
}

//______________________________________________________________________________
const char *Digitiser::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Digitiser::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Digitiser::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Digitiser::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Digitiser*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr ECAHeader::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ECAHeader::Class_Name()
{
   return "RAT::DS::ECAHeader";
}

//______________________________________________________________________________
const char *ECAHeader::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ECAHeader::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void ECAHeader::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *ECAHeader::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::ECAHeader*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr UniversalTime::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *UniversalTime::Class_Name()
{
   return "RAT::DS::UniversalTime";
}

//______________________________________________________________________________
const char *UniversalTime::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int UniversalTime::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void UniversalTime::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *UniversalTime::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::UniversalTime*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr FitVertex::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *FitVertex::Class_Name()
{
   return "RAT::DS::FitVertex";
}

//______________________________________________________________________________
const char *FitVertex::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int FitVertex::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void FitVertex::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *FitVertex::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitVertex*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr FitResult::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *FitResult::Class_Name()
{
   return "RAT::DS::FitResult";
}

//______________________________________________________________________________
const char *FitResult::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int FitResult::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void FitResult::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *FitResult::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitResult*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr FitClassifierCollection<RAT::DS::FitResult>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *FitClassifierCollection<RAT::DS::FitResult>::Class_Name()
{
   return "RAT::DS::FitClassifierCollection<RAT::DS::FitResult>";
}

//______________________________________________________________________________
template <> const char *FitClassifierCollection<RAT::DS::FitResult>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int FitClassifierCollection<RAT::DS::FitResult>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void FitClassifierCollection<RAT::DS::FitResult>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *FitClassifierCollection<RAT::DS::FitResult>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr FitClassifierCollection<RAT::DS::ClassifierResult>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Name()
{
   return "RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>";
}

//______________________________________________________________________________
template <> const char *FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void FitClassifierCollection<RAT::DS::ClassifierResult>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *FitClassifierCollection<RAT::DS::ClassifierResult>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr PMTCal::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PMTCal::Class_Name()
{
   return "RAT::DS::PMTCal";
}

//______________________________________________________________________________
const char *PMTCal::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PMTCal::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PMTCal::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PMTCal::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTCal*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr PMT<Double32_t>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *PMT<Double32_t>::Class_Name()
{
   return "RAT::DS::PMT<Double32_t>";
}

//______________________________________________________________________________
template <> const char *PMT<Double32_t>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int PMT<Double32_t>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void PMT<Double32_t>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *PMT<Double32_t>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr PMT<unsigned short>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *PMT<unsigned short>::Class_Name()
{
   return "RAT::DS::PMT<unsigned short>";
}

//______________________________________________________________________________
template <> const char *PMT<unsigned short>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int PMT<unsigned short>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void PMT<unsigned short>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *PMT<unsigned short>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCHit::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCHit::Class_Name()
{
   return "RAT::DS::MCHit";
}

//______________________________________________________________________________
const char *MCHit::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCHit::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCHit::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCHit::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCHit*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr PMTInfo::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PMTInfo::Class_Name()
{
   return "RAT::DU::PMTInfo";
}

//______________________________________________________________________________
const char *PMTInfo::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PMTInfo::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PMTInfo::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PMTInfo::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTInfo*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr PMTSet<RAT::DS::PMT<unsigned short> >::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::PMT<unsigned short> >::Class_Name()
{
   return "RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >";
}

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void PMTSet<RAT::DS::PMT<unsigned short> >::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *PMTSet<RAT::DS::PMT<unsigned short> >::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr PMTSet<RAT::DS::PMTCal>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::PMTCal>::Class_Name()
{
   return "RAT::DS::PMTSet<RAT::DS::PMTCal>";
}

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::PMTCal>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int PMTSet<RAT::DS::PMTCal>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void PMTSet<RAT::DS::PMTCal>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *PMTSet<RAT::DS::PMTCal>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> atomic_TClass_ptr PMTSet<RAT::DS::MCHit>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::MCHit>::Class_Name()
{
   return "RAT::DS::PMTSet<RAT::DS::MCHit>";
}

//______________________________________________________________________________
template <> const char *PMTSet<RAT::DS::MCHit>::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int PMTSet<RAT::DS::MCHit>::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void PMTSet<RAT::DS::MCHit>::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *PMTSet<RAT::DS::MCHit>::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr EV::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *EV::Class_Name()
{
   return "RAT::DS::EV";
}

//______________________________________________________________________________
const char *EV::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::EV*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EV::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::EV*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EV::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::EV*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *EV::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::EV*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr TrigHeader::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *TrigHeader::Class_Name()
{
   return "RAT::DS::TrigHeader";
}

//______________________________________________________________________________
const char *TrigHeader::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TrigHeader::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TrigHeader::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TrigHeader::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::TrigHeader*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr HeaderInfo::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *HeaderInfo::Class_Name()
{
   return "RAT::DS::HeaderInfo";
}

//______________________________________________________________________________
const char *HeaderInfo::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int HeaderInfo::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void HeaderInfo::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *HeaderInfo::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::HeaderInfo*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MetaDB::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MetaDB::Class_Name()
{
   return "RAT::DS::MetaDB";
}

//______________________________________________________________________________
const char *MetaDB::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MetaDB::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MetaDB::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MetaDB::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MetaDB*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr Run::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Run::Class_Name()
{
   return "RAT::DS::Run";
}

//______________________________________________________________________________
const char *Run::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Run*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Run::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Run*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Run::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Run*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Run::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Run*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr Meta::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Meta::Class_Name()
{
   return "RAT::DS::Meta";
}

//______________________________________________________________________________
const char *Meta::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Meta::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Meta::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Meta::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Meta*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCParticle::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCParticle::Class_Name()
{
   return "RAT::DS::MCParticle";
}

//______________________________________________________________________________
const char *MCParticle::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCParticle::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCParticle::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCParticle::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCParticle*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCTrackStep::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCTrackStep::Class_Name()
{
   return "RAT::DS::MCTrackStep";
}

//______________________________________________________________________________
const char *MCTrackStep::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCTrackStep::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCTrackStep::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCTrackStep::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrackStep*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCTrack::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCTrack::Class_Name()
{
   return "RAT::DS::MCTrack";
}

//______________________________________________________________________________
const char *MCTrack::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCTrack::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCTrack::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCTrack::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCTrack*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCPhoton::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCPhoton::Class_Name()
{
   return "RAT::DS::MCPhoton";
}

//______________________________________________________________________________
const char *MCPhoton::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCPhoton::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCPhoton::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCPhoton::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPhoton*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCPE::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCPE::Class_Name()
{
   return "RAT::DS::MCPE";
}

//______________________________________________________________________________
const char *MCPE::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCPE::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCPE::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCPE::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPE*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCPMT::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCPMT::Class_Name()
{
   return "RAT::DS::MCPMT";
}

//______________________________________________________________________________
const char *MCPMT::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCPMT::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCPMT::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCPMT::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCPMT*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MC::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MC::Class_Name()
{
   return "RAT::DS::MC";
}

//______________________________________________________________________________
const char *MC::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MC*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MC::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MC*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MC::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MC*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MC::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MC*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr MCEV::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCEV::Class_Name()
{
   return "RAT::DS::MCEV";
}

//______________________________________________________________________________
const char *MCEV::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCEV::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCEV::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCEV::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::MCEV*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr Entry::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Entry::Class_Name()
{
   return "RAT::DS::Entry";
}

//______________________________________________________________________________
const char *Entry::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Entry::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Entry::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Entry::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::Entry*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr SOCPMT::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *SOCPMT::Class_Name()
{
   return "RAT::DS::SOCPMT";
}

//______________________________________________________________________________
const char *SOCPMT::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SOCPMT::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SOCPMT::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SOCPMT::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOCPMT*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
atomic_TClass_ptr SOC::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *SOC::Class_Name()
{
   return "RAT::DS::SOC";
}

//______________________________________________________________________________
const char *SOC::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SOC::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SOC::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SOC::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::SOC*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DS
} // namespace RAT::DS
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr DataCleaningBits::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DataCleaningBits::Class_Name()
{
   return "RAT::DU::DataCleaningBits";
}

//______________________________________________________________________________
const char *DataCleaningBits::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DataCleaningBits::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DataCleaningBits::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DataCleaningBits::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataCleaningBits*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr DataQualityBits::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DataQualityBits::Class_Name()
{
   return "RAT::DU::DataQualityBits";
}

//______________________________________________________________________________
const char *DataQualityBits::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DataQualityBits::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DataQualityBits::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DataQualityBits::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DataQualityBits*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr ChanSWStatus::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ChanSWStatus::Class_Name()
{
   return "RAT::DU::ChanSWStatus";
}

//______________________________________________________________________________
const char *ChanSWStatus::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ChanSWStatus::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void ChanSWStatus::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *ChanSWStatus::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanSWStatus*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr TrigBits::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *TrigBits::Class_Name()
{
   return "RAT::DU::TrigBits";
}

//______________________________________________________________________________
const char *TrigBits::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TrigBits::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TrigBits::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TrigBits::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TrigBits*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr DSReader::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DSReader::Class_Name()
{
   return "RAT::DU::DSReader";
}

//______________________________________________________________________________
const char *DSReader::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DSReader::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DSReader::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DSReader::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::DSReader*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr EffectiveVelocity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *EffectiveVelocity::Class_Name()
{
   return "RAT::DU::EffectiveVelocity";
}

//______________________________________________________________________________
const char *EffectiveVelocity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EffectiveVelocity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EffectiveVelocity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *EffectiveVelocity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EffectiveVelocity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
//______________________________________________________________________________
atomic_TClass_ptr DB::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *DB::Class_Name()
{
   return "RAT::DB";
}

//______________________________________________________________________________
const char *DB::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DB*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int DB::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DB*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void DB::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DB*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *DB::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DB*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr GroupVelocity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *GroupVelocity::Class_Name()
{
   return "RAT::DU::GroupVelocity";
}

//______________________________________________________________________________
const char *GroupVelocity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int GroupVelocity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void GroupVelocity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *GroupVelocity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::GroupVelocity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr LightPathCalculator::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *LightPathCalculator::Class_Name()
{
   return "RAT::DU::LightPathCalculator";
}

//______________________________________________________________________________
const char *LightPathCalculator::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int LightPathCalculator::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void LightPathCalculator::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *LightPathCalculator::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::LightPathCalculator*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr PanelInfo::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PanelInfo::Class_Name()
{
   return "RAT::DU::PanelInfo";
}

//______________________________________________________________________________
const char *PanelInfo::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PanelInfo::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PanelInfo::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PanelInfo::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PanelInfo*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr ChanHWStatus::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *ChanHWStatus::Class_Name()
{
   return "RAT::DU::ChanHWStatus";
}

//______________________________________________________________________________
const char *ChanHWStatus::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int ChanHWStatus::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void ChanHWStatus::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *ChanHWStatus::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ChanHWStatus*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr PMTCalStatus::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PMTCalStatus::Class_Name()
{
   return "RAT::DU::PMTCalStatus";
}

//______________________________________________________________________________
const char *PMTCalStatus::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PMTCalStatus::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PMTCalStatus::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PMTCalStatus::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::PMTCalStatus*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr Segmentor::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Segmentor::Class_Name()
{
   return "RAT::DU::Segmentor";
}

//______________________________________________________________________________
const char *Segmentor::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Segmentor::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Segmentor::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Segmentor::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Segmentor*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr SOCReader::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *SOCReader::Class_Name()
{
   return "RAT::DU::SOCReader";
}

//______________________________________________________________________________
const char *SOCReader::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SOCReader::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SOCReader::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SOCReader::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::SOCReader*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr TimeResidualCalculator::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *TimeResidualCalculator::Class_Name()
{
   return "RAT::DU::TimeResidualCalculator";
}

//______________________________________________________________________________
const char *TimeResidualCalculator::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TimeResidualCalculator::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TimeResidualCalculator::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TimeResidualCalculator::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::TimeResidualCalculator*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr Utility::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Utility::Class_Name()
{
   return "RAT::DU::Utility";
}

//______________________________________________________________________________
const char *Utility::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Utility::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Utility::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Utility::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Utility*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
//______________________________________________________________________________
atomic_TClass_ptr TrackNode::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *TrackNode::Class_Name()
{
   return "RAT::TrackNode";
}

//______________________________________________________________________________
const char *TrackNode::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackNode*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TrackNode::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackNode*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TrackNode::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackNode*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TrackNode::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::TrackNode*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr EnergySystematics::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *EnergySystematics::Class_Name()
{
   return "RAT::DU::EnergySystematics";
}

//______________________________________________________________________________
const char *EnergySystematics::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int EnergySystematics::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void EnergySystematics::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *EnergySystematics::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::EnergySystematics*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DU {
//______________________________________________________________________________
atomic_TClass_ptr Point3D::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Point3D::Class_Name()
{
   return "RAT::DU::Point3D";
}

//______________________________________________________________________________
const char *Point3D::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Point3D::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Point3D::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Point3D::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::Point3D*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace RAT::DU
} // namespace RAT::DU
      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void BitMask::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::BitMask.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::BitMask::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::BitMask::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void BitMask::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::BitMask.
      TClass *R__cl = ::RAT::DS::BitMask::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flags", (void*)&flags);
      R__insp.InspectMember("vector<ULong64_t>", (void*)&flags, "flags.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLBitMask(void *p) {
      return  p ? new(p) ::RAT::DS::BitMask : new ::RAT::DS::BitMask;
   }
   static void *newArray_RATcLcLDScLcLBitMask(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::BitMask[nElements] : new ::RAT::DS::BitMask[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLBitMask(void *p) {
      delete ((::RAT::DS::BitMask*)p);
   }
   static void deleteArray_RATcLcLDScLcLBitMask(void *p) {
      delete [] ((::RAT::DS::BitMask*)p);
   }
   static void destruct_RATcLcLDScLcLBitMask(void *p) {
      typedef ::RAT::DS::BitMask current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::BitMask

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void Calib::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::Calib.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::Calib::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::Calib::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void Calib::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::Calib.
      TClass *R__cl = ::RAT::DS::Calib::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "sourceName", (void*)&sourceName);
      R__insp.InspectMember("string", (void*)&sourceName, "sourceName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mode", &mode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "intensity", &intensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "time", &time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pos", &pos);
      R__insp.InspectMember(pos, "pos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dir", &dir);
      R__insp.InspectMember(dir, "dir.");
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLCalib(void *p) {
      return  p ? new(p) ::RAT::DS::Calib : new ::RAT::DS::Calib;
   }
   static void *newArray_RATcLcLDScLcLCalib(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::Calib[nElements] : new ::RAT::DS::Calib[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLCalib(void *p) {
      delete ((::RAT::DS::Calib*)p);
   }
   static void deleteArray_RATcLcLDScLcLCalib(void *p) {
      delete [] ((::RAT::DS::Calib*)p);
   }
   static void destruct_RATcLcLDScLcLCalib(void *p) {
      typedef ::RAT::DS::Calib current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::Calib

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void ClassifierResult::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::ClassifierResult.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::ClassifierResult::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::ClassifierResult::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void ClassifierResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::ClassifierResult.
      TClass *R__cl = ::RAT::DS::ClassifierResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "classifications", (void*)&classifications);
      R__insp.InspectMember("map<std::string,Double32_t>", (void*)&classifications, "classifications.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "foms", (void*)&foms);
      R__insp.InspectMember("map<std::string,Double32_t>", (void*)&foms, "foms.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "executionTime", &executionTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "valid", &valid);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLClassifierResult(void *p) {
      return  p ? new(p) ::RAT::DS::ClassifierResult : new ::RAT::DS::ClassifierResult;
   }
   static void *newArray_RATcLcLDScLcLClassifierResult(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::ClassifierResult[nElements] : new ::RAT::DS::ClassifierResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLClassifierResult(void *p) {
      delete ((::RAT::DS::ClassifierResult*)p);
   }
   static void deleteArray_RATcLcLDScLcLClassifierResult(void *p) {
      delete [] ((::RAT::DS::ClassifierResult*)p);
   }
   static void destruct_RATcLcLDScLcLClassifierResult(void *p) {
      typedef ::RAT::DS::ClassifierResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::ClassifierResult

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void DataQCFlags::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::DataQCFlags.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::DataQCFlags::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::DataQCFlags::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void DataQCFlags::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::DataQCFlags.
      TClass *R__cl = ::RAT::DS::DataQCFlags::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flags", (void*)&flags);
      R__insp.InspectMember("map<UInt_t,BitMask>", (void*)&flags, "flags.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "applied", (void*)&applied);
      R__insp.InspectMember("map<UInt_t,BitMask>", (void*)&applied, "applied.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLDataQCFlags(void *p) {
      return  p ? new(p) ::RAT::DS::DataQCFlags : new ::RAT::DS::DataQCFlags;
   }
   static void *newArray_RATcLcLDScLcLDataQCFlags(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::DataQCFlags[nElements] : new ::RAT::DS::DataQCFlags[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLDataQCFlags(void *p) {
      delete ((::RAT::DS::DataQCFlags*)p);
   }
   static void deleteArray_RATcLcLDScLcLDataQCFlags(void *p) {
      delete [] ((::RAT::DS::DataQCFlags*)p);
   }
   static void destruct_RATcLcLDScLcLDataQCFlags(void *p) {
      typedef ::RAT::DS::DataQCFlags current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::DataQCFlags

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void Digitiser::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::Digitiser.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::Digitiser::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::Digitiser::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void Digitiser::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::Digitiser.
      TClass *R__cl = ::RAT::DS::Digitiser::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "waveforms", (void*)&waveforms);
      R__insp.InspectMember("map<UShort_t,std::vector<UShort_t> >", (void*)&waveforms, "waveforms.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eventID", &eventID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trigTime", &trigTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nWords", &nWords);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "boardID", &boardID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bit24", &bit24);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dataFormat", &dataFormat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ioPins", &ioPins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chanMask", &chanMask);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLDigitiser(void *p) {
      return  p ? new(p) ::RAT::DS::Digitiser : new ::RAT::DS::Digitiser;
   }
   static void *newArray_RATcLcLDScLcLDigitiser(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::Digitiser[nElements] : new ::RAT::DS::Digitiser[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLDigitiser(void *p) {
      delete ((::RAT::DS::Digitiser*)p);
   }
   static void deleteArray_RATcLcLDScLcLDigitiser(void *p) {
      delete [] ((::RAT::DS::Digitiser*)p);
   }
   static void destruct_RATcLcLDScLcLDigitiser(void *p) {
      typedef ::RAT::DS::Digitiser current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::Digitiser

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void ECAHeader::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::ECAHeader.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::ECAHeader::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::ECAHeader::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void ECAHeader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::ECAHeader.
      TClass *R__cl = ::RAT::DS::ECAHeader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "gtDelayCoarse", &gtDelayCoarse);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "gtDelayFine", &gtDelayFine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chargePedestalAmplitude", &chargePedestalAmplitude);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chargePedestalWidth", &chargePedestalWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "patternID", &patternID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "calType", &calType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nTSlopePoints", &nTSlopePoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flag", &flag);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLECAHeader(void *p) {
      return  p ? new(p) ::RAT::DS::ECAHeader : new ::RAT::DS::ECAHeader;
   }
   static void *newArray_RATcLcLDScLcLECAHeader(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::ECAHeader[nElements] : new ::RAT::DS::ECAHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLECAHeader(void *p) {
      delete ((::RAT::DS::ECAHeader*)p);
   }
   static void deleteArray_RATcLcLDScLcLECAHeader(void *p) {
      delete [] ((::RAT::DS::ECAHeader*)p);
   }
   static void destruct_RATcLcLDScLcLECAHeader(void *p) {
      typedef ::RAT::DS::ECAHeader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::ECAHeader

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void Entry::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::Entry.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::Entry::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::Entry::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void Entry::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::Entry.
      TClass *R__cl = ::RAT::DS::Entry::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mc", (void*)&mc);
      R__insp.InspectMember("vector<MC>", (void*)&mc, "mc.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcevs", (void*)&mcevs);
      R__insp.InspectMember("vector<MCEV>", (void*)&mcevs, "mcevs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "evs", (void*)&evs);
      R__insp.InspectMember("vector<EV>", (void*)&evs, "evs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "headerInfo", (void*)&headerInfo);
      R__insp.InspectMember("vector<HeaderInfo>", (void*)&headerInfo, "headerInfo.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "calib", &calib);
      R__insp.InspectMember(calib, "calib.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "runID", &runID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "subRunID", &subRunID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "seed", &seed);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLEntry(void *p) {
      return  p ? new(p) ::RAT::DS::Entry : new ::RAT::DS::Entry;
   }
   static void *newArray_RATcLcLDScLcLEntry(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::Entry[nElements] : new ::RAT::DS::Entry[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLEntry(void *p) {
      delete ((::RAT::DS::Entry*)p);
   }
   static void deleteArray_RATcLcLDScLcLEntry(void *p) {
      delete [] ((::RAT::DS::Entry*)p);
   }
   static void destruct_RATcLcLDScLcLEntry(void *p) {
      typedef ::RAT::DS::Entry current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::Entry

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void EV::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::EV.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::EV::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::EV::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void EV::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::EV.
      TClass *R__cl = ::RAT::DS::EV::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "universalTime", &universalTime);
      R__insp.InspectMember(universalTime, "universalTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dataCleaningFlags", &dataCleaningFlags);
      R__insp.InspectMember(dataCleaningFlags, "dataCleaningFlags.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "uncalPMTs", &uncalPMTs);
      R__insp.InspectMember(uncalPMTs, "uncalPMTs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "calPMTs", &calPMTs);
      R__insp.InspectMember(calPMTs, "calPMTs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "partialCalPMTs", (void*)&partialCalPMTs);
      R__insp.InspectMember("map<UInt_t,CalPMTs>", (void*)&partialCalPMTs, "partialCalPMTs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fitName", (void*)&fitName);
      R__insp.InspectMember("string", (void*)&fitName, "fitName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fit", (void*)&fit);
      R__insp.InspectMember("vector<FitVertex>", (void*)&fit, "fit.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fitResults", (void*)&fitResults);
      R__insp.InspectMember("map<UInt_t,FitCollection>", (void*)&fitResults, "fitResults.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "classifierResults", (void*)&classifierResults);
      R__insp.InspectMember("map<UInt_t,ClassifierCollection>", (void*)&classifierResults, "classifierResults.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "digitiser", (void*)&digitiser);
      R__insp.InspectMember("vector<Digitiser>", (void*)&digitiser, "digitiser.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "clockCount50", &clockCount50);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "clockCount10", &clockCount10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pmtCalType", &pmtCalType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "gtid", &gtid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nhits", &nhits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nhits_cleaned", &nhits_cleaned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inTimeHits100", &inTimeHits100);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inTimeHits20", &inTimeHits20);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "totalCharge", &totalCharge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eSumPeak", &eSumPeak);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eSumDerivative", &eSumDerivative);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eSumIntegral", &eSumIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dataSet", &dataSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trigError", &trigError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trigType", &trigType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tubiiTrig", &tubiiTrig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "clockStat10", &clockStat10);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "iscal", &iscal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ispolling", &ispolling);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLEV(void *p) {
      return  p ? new(p) ::RAT::DS::EV : new ::RAT::DS::EV;
   }
   static void *newArray_RATcLcLDScLcLEV(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::EV[nElements] : new ::RAT::DS::EV[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLEV(void *p) {
      delete ((::RAT::DS::EV*)p);
   }
   static void deleteArray_RATcLcLDScLcLEV(void *p) {
      delete [] ((::RAT::DS::EV*)p);
   }
   static void destruct_RATcLcLDScLcLEV(void *p) {
      typedef ::RAT::DS::EV current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::EV

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void FitResult::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::FitResult.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::FitResult::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::FitResult::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void FitResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::FitResult.
      TClass *R__cl = ::RAT::DS::FitResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "foms", (void*)&foms);
      R__insp.InspectMember("map<std::string,Double32_t>", (void*)&foms, "foms.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "vertices", (void*)&vertices);
      R__insp.InspectMember("vector<FitVertex>", (void*)&vertices, "vertices.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "executionTime", &executionTime);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLFitResult(void *p) {
      return  p ? new(p) ::RAT::DS::FitResult : new ::RAT::DS::FitResult;
   }
   static void *newArray_RATcLcLDScLcLFitResult(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::FitResult[nElements] : new ::RAT::DS::FitResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLFitResult(void *p) {
      delete ((::RAT::DS::FitResult*)p);
   }
   static void deleteArray_RATcLcLDScLcLFitResult(void *p) {
      delete [] ((::RAT::DS::FitResult*)p);
   }
   static void destruct_RATcLcLDScLcLFitResult(void *p) {
      typedef ::RAT::DS::FitResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::FitResult

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void FitClassifierCollection<RAT::DS::FitResult>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::FitClassifierCollection<RAT::DS::FitResult>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::FitClassifierCollection<RAT::DS::FitResult>.
      typedef ::ROOTShadow::Shadow::RAT::DS::FitClassifierCollectionlERATcLcLDScLcLFitResultgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "results", (void*)&sobj->results);
      R__insp.InspectMember("map<std::string,RAT::DS::FitResult>", (void*)&sobj->results, "results.", false);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void FitClassifierCollection<RAT::DS::FitResult>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) {
      return  p ? new(p) ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult> : new ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>;
   }
   static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>[nElements] : new ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) {
      delete ((::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)p);
   }
   static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) {
      delete [] ((::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)p);
   }
   static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void *p) {
      typedef ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::FitClassifierCollection<RAT::DS::FitResult>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void FitClassifierCollection<RAT::DS::ClassifierResult>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>.
      typedef ::ROOTShadow::Shadow::RAT::DS::FitClassifierCollectionlERATcLcLDScLcLClassifierResultgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "results", (void*)&sobj->results);
      R__insp.InspectMember("map<std::string,RAT::DS::ClassifierResult>", (void*)&sobj->results, "results.", false);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void FitClassifierCollection<RAT::DS::ClassifierResult>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) {
      return  p ? new(p) ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> : new ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>;
   }
   static void *newArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>[nElements] : new ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) {
      delete ((::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)p);
   }
   static void deleteArray_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) {
      delete [] ((::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)p);
   }
   static void destruct_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void *p) {
      typedef ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void FitVertex::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::FitVertex.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::FitVertex::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::FitVertex::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void FitVertex::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::FitVertex.
      TClass *R__cl = ::RAT::DS::FitVertex::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "position", (void*)&position);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&position, "position.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "positivePositionError", (void*)&positivePositionError);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&positivePositionError, "positivePositionError.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "negativePositionError", (void*)&negativePositionError);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&negativePositionError, "negativePositionError.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "direction", (void*)&direction);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&direction, "direction.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "positiveDirectionError", (void*)&positiveDirectionError);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&positiveDirectionError, "positiveDirectionError.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "negativeDirectionError", (void*)&negativeDirectionError);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&negativeDirectionError, "negativeDirectionError.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "energy", &energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "positiveEnergyError", &positiveEnergyError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "negativeEnergyError", &negativeEnergyError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "time", &time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "positiveTimeError", &positiveTimeError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "negativeTimeError", &negativeTimeError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dataMask", &dataMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "validMask", &validMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fixedMask", &fixedMask);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLFitVertex(void *p) {
      return  p ? new(p) ::RAT::DS::FitVertex : new ::RAT::DS::FitVertex;
   }
   static void *newArray_RATcLcLDScLcLFitVertex(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::FitVertex[nElements] : new ::RAT::DS::FitVertex[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLFitVertex(void *p) {
      delete ((::RAT::DS::FitVertex*)p);
   }
   static void deleteArray_RATcLcLDScLcLFitVertex(void *p) {
      delete [] ((::RAT::DS::FitVertex*)p);
   }
   static void destruct_RATcLcLDScLcLFitVertex(void *p) {
      typedef ::RAT::DS::FitVertex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::FitVertex

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void HeaderInfo::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::HeaderInfo.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::HeaderInfo::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::HeaderInfo::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void HeaderInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::HeaderInfo.
      TClass *R__cl = ::RAT::DS::HeaderInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ecaHeader", (void*)&ecaHeader);
      R__insp.InspectMember("vector<ECAHeader>", (void*)&ecaHeader, "ecaHeader.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trigHeader", (void*)&trigHeader);
      R__insp.InspectMember("vector<TrigHeader>", (void*)&trigHeader, "trigHeader.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLHeaderInfo(void *p) {
      return  p ? new(p) ::RAT::DS::HeaderInfo : new ::RAT::DS::HeaderInfo;
   }
   static void *newArray_RATcLcLDScLcLHeaderInfo(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::HeaderInfo[nElements] : new ::RAT::DS::HeaderInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLHeaderInfo(void *p) {
      delete ((::RAT::DS::HeaderInfo*)p);
   }
   static void deleteArray_RATcLcLDScLcLHeaderInfo(void *p) {
      delete [] ((::RAT::DS::HeaderInfo*)p);
   }
   static void destruct_RATcLcLDScLcLHeaderInfo(void *p) {
      typedef ::RAT::DS::HeaderInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::HeaderInfo

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MC::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MC.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MC::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MC::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MC::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MC.
      TClass *R__cl = ::RAT::DS::MC::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "particles", (void*)&particles);
      R__insp.InspectMember("vector<MCParticle>", (void*)&particles, "particles.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "parents", (void*)&parents);
      R__insp.InspectMember("vector<MCParticle>", (void*)&parents, "parents.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tracks", (void*)&tracks);
      R__insp.InspectMember("vector<MCTrack>", (void*)&tracks, "tracks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trackIDs", (void*)&trackIDs);
      R__insp.InspectMember("vector<unsigned int>", (void*)&trackIDs, "trackIDs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pmts", (void*)&pmts);
      R__insp.InspectMember("vector<MCPMT>", (void*)&pmts, "pmts.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "unbuiltHits", &unbuiltHits);
      R__insp.InspectMember(unbuiltHits, "unbuiltHits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "universalTime", &universalTime);
      R__insp.InspectMember(universalTime, "universalTime.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcTime", &mcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcid", &mcid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcPECount", &mcPECount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nCherPhotons", &nCherPhotons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nScintPhotons", &nScintPhotons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nReemittedPhotons", &nReemittedPhotons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "numDirPE", &numDirPE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "intialScintTime", &intialScintTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "scintEnergyDeposit", &scintEnergyDeposit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "scintQuenchedEnergyDeposit", &scintQuenchedEnergyDeposit);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMC(void *p) {
      return  p ? new(p) ::RAT::DS::MC : new ::RAT::DS::MC;
   }
   static void *newArray_RATcLcLDScLcLMC(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MC[nElements] : new ::RAT::DS::MC[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMC(void *p) {
      delete ((::RAT::DS::MC*)p);
   }
   static void deleteArray_RATcLcLDScLcLMC(void *p) {
      delete [] ((::RAT::DS::MC*)p);
   }
   static void destruct_RATcLcLDScLcLMC(void *p) {
      typedef ::RAT::DS::MC current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MC

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCEV::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCEV.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCEV::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCEV::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCEV::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCEV.
      TClass *R__cl = ::RAT::DS::MCEV::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hits", &hits);
      R__insp.InspectMember(hits, "hits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "gtid", &gtid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "gtTime", &gtTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fullTrigType", &fullTrigType);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCEV(void *p) {
      return  p ? new(p) ::RAT::DS::MCEV : new ::RAT::DS::MCEV;
   }
   static void *newArray_RATcLcLDScLcLMCEV(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCEV[nElements] : new ::RAT::DS::MCEV[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCEV(void *p) {
      delete ((::RAT::DS::MCEV*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCEV(void *p) {
      delete [] ((::RAT::DS::MCEV*)p);
   }
   static void destruct_RATcLcLDScLcLMCEV(void *p) {
      typedef ::RAT::DS::MCEV current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCEV

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCPMT::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCPMT.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCPMT::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCPMT::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCPMT::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCPMT.
      TClass *R__cl = ::RAT::DS::MCPMT::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcPhotons", (void*)&mcPhotons);
      R__insp.InspectMember("vector<MCPhoton>", (void*)&mcPhotons, "mcPhotons.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcPEs", (void*)&mcPEs);
      R__insp.InspectMember("vector<MCPE>", (void*)&mcPEs, "mcPEs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCPMT(void *p) {
      return  p ? new(p) ::RAT::DS::MCPMT : new ::RAT::DS::MCPMT;
   }
   static void *newArray_RATcLcLDScLcLMCPMT(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCPMT[nElements] : new ::RAT::DS::MCPMT[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCPMT(void *p) {
      delete ((::RAT::DS::MCPMT*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCPMT(void *p) {
      delete [] ((::RAT::DS::MCPMT*)p);
   }
   static void destruct_RATcLcLDScLcLMCPMT(void *p) {
      typedef ::RAT::DS::MCPMT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCPMT

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCParticle::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCParticle.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCParticle::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCParticle::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCParticle::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCParticle.
      TClass *R__cl = ::RAT::DS::MCParticle::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "position", (void*)&position);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&position, "position.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "polarisation", (void*)&polarisation);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&polarisation, "polarisation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "momentum", (void*)&momentum);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&momentum, "momentum.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pdgCode", &pdgCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcTime", &mcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "kineticEnergy", &kineticEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "vertexID", &vertexID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "metaInfo", (void*)&metaInfo);
      R__insp.InspectMember("string", (void*)&metaInfo, "metaInfo.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCParticle(void *p) {
      return  p ? new(p) ::RAT::DS::MCParticle : new ::RAT::DS::MCParticle;
   }
   static void *newArray_RATcLcLDScLcLMCParticle(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCParticle[nElements] : new ::RAT::DS::MCParticle[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCParticle(void *p) {
      delete ((::RAT::DS::MCParticle*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCParticle(void *p) {
      delete [] ((::RAT::DS::MCParticle*)p);
   }
   static void destruct_RATcLcLDScLcLMCParticle(void *p) {
      typedef ::RAT::DS::MCParticle current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCParticle

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCPE::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCPE.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCPE::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCPE::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCPE::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCPE.
      TClass *R__cl = ::RAT::DS::MCPE::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "position", (void*)&position);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&position, "position.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "creationTime", &creationTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "frontEndTime", &frontEndTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "charge", &charge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "photonTrackID", &photonTrackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "noise", &noise);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "afterpulse", &afterpulse);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "photonHistory", &photonHistory);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCPE(void *p) {
      return  p ? new(p) ::RAT::DS::MCPE : new ::RAT::DS::MCPE;
   }
   static void *newArray_RATcLcLDScLcLMCPE(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCPE[nElements] : new ::RAT::DS::MCPE[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCPE(void *p) {
      delete ((::RAT::DS::MCPE*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCPE(void *p) {
      delete [] ((::RAT::DS::MCPE*)p);
   }
   static void destruct_RATcLcLDScLcLMCPE(void *p) {
      typedef ::RAT::DS::MCPE current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCPE

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCPhoton::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCPhoton.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCPhoton::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCPhoton::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCPhoton::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCPhoton.
      TClass *R__cl = ::RAT::DS::MCPhoton::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inPosition", (void*)&inPosition);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&inPosition, "inPosition.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inDirection", (void*)&inDirection);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&inDirection, "inDirection.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inPolarisation", (void*)&inPolarisation);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&inPolarisation, "inPolarisation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "outPosition", (void*)&outPosition);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&outPosition, "outPosition.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "outDirection", (void*)&outDirection);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&outDirection, "outDirection.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "outPolarisation", (void*)&outPolarisation);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&outPolarisation, "outPolarisation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inTime", &inTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "outTime", &outTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "energy", &energy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "weight", &weight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "photonTrackID", &photonTrackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fate", &fate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pmtID", &pmtID);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCPhoton(void *p) {
      return  p ? new(p) ::RAT::DS::MCPhoton : new ::RAT::DS::MCPhoton;
   }
   static void *newArray_RATcLcLDScLcLMCPhoton(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCPhoton[nElements] : new ::RAT::DS::MCPhoton[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCPhoton(void *p) {
      delete ((::RAT::DS::MCPhoton*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCPhoton(void *p) {
      delete [] ((::RAT::DS::MCPhoton*)p);
   }
   static void destruct_RATcLcLDScLcLMCPhoton(void *p) {
      typedef ::RAT::DS::MCPhoton current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCPhoton

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCTrack.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCTrack::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCTrack::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCTrack.
      TClass *R__cl = ::RAT::DS::MCTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "steps", (void*)&steps);
      R__insp.InspectMember("vector<MCTrackStep>", (void*)&steps, "steps.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "particleName", (void*)&particleName);
      R__insp.InspectMember("string", (void*)&particleName, "particleName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "summaryFlag", &summaryFlag);
      R__insp.InspectMember(summaryFlag, "summaryFlag.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trackID", &trackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "parentID", &parentID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pdgCode", &pdgCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "length", &length);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "depositedEnergy", &depositedEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "weight", &weight);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCTrack(void *p) {
      return  p ? new(p) ::RAT::DS::MCTrack : new ::RAT::DS::MCTrack;
   }
   static void *newArray_RATcLcLDScLcLMCTrack(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCTrack[nElements] : new ::RAT::DS::MCTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCTrack(void *p) {
      delete ((::RAT::DS::MCTrack*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCTrack(void *p) {
      delete [] ((::RAT::DS::MCTrack*)p);
   }
   static void destruct_RATcLcLDScLcLMCTrack(void *p) {
      typedef ::RAT::DS::MCTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCTrack

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCTrackStep::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCTrackStep.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCTrackStep::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCTrackStep::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCTrackStep::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCTrackStep.
      TClass *R__cl = ::RAT::DS::MCTrackStep::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "position", (void*)&position);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&position, "position.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "polarisation", (void*)&polarisation);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&polarisation, "polarisation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "momentum", (void*)&momentum);
      R__insp.InspectMember("ROOT::Math::XYZVectorF", (void*)&momentum, "momentum.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "startVolume", (void*)&startVolume);
      R__insp.InspectMember("string", (void*)&startVolume, "startVolume.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "endVolume", (void*)&endVolume);
      R__insp.InspectMember("string", (void*)&endVolume, "endVolume.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "length", &length);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "globalTime", &globalTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "localTime", &localTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "properTime", &properTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "kineticEnergy", &kineticEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "depositedEnergy", &depositedEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "status", &status);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "process", &process);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCTrackStep(void *p) {
      return  p ? new(p) ::RAT::DS::MCTrackStep : new ::RAT::DS::MCTrackStep;
   }
   static void *newArray_RATcLcLDScLcLMCTrackStep(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCTrackStep[nElements] : new ::RAT::DS::MCTrackStep[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCTrackStep(void *p) {
      delete ((::RAT::DS::MCTrackStep*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCTrackStep(void *p) {
      delete [] ((::RAT::DS::MCTrackStep*)p);
   }
   static void destruct_RATcLcLDScLcLMCTrackStep(void *p) {
      typedef ::RAT::DS::MCTrackStep current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCTrackStep

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void Meta::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::Meta.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::Meta::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::Meta::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void Meta::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::Meta.
      TClass *R__cl = ::RAT::DS::Meta::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "metaDBs", (void*)&metaDBs);
      R__insp.InspectMember("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >", (void*)&metaDBs, "metaDBs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hostNames", (void*)&hostNames);
      R__insp.InspectMember("vector<std::string>", (void*)&hostNames, "hostNames.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hostSystems", (void*)&hostSystems);
      R__insp.InspectMember("vector<std::string>", (void*)&hostSystems, "hostSystems.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ratVersions", (void*)&ratVersions);
      R__insp.InspectMember("vector<std::string>", (void*)&ratVersions, "ratVersions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ratRevisions", (void*)&ratRevisions);
      R__insp.InspectMember("vector<std::string>", (void*)&ratRevisions, "ratRevisions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "geant4Versions", (void*)&geant4Versions);
      R__insp.InspectMember("vector<std::string>", (void*)&geant4Versions, "geant4Versions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "rootVersions", (void*)&rootVersions);
      R__insp.InspectMember("vector<std::string>", (void*)&rootVersions, "rootVersions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "containsMCFlags", (void*)&containsMCFlags);
      R__insp.InspectMember("vector<Int_t>", (void*)&containsMCFlags, "containsMCFlags.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "containsDataFlags", (void*)&containsDataFlags);
      R__insp.InspectMember("vector<Int_t>", (void*)&containsDataFlags, "containsDataFlags.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eventsGeneratedCounts", (void*)&eventsGeneratedCounts);
      R__insp.InspectMember("vector<Int_t>", (void*)&eventsGeneratedCounts, "eventsGeneratedCounts.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "eventsStoredCounts", (void*)&eventsStoredCounts);
      R__insp.InspectMember("vector<Int_t>", (void*)&eventsStoredCounts, "eventsStoredCounts.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMeta(void *p) {
      return  p ? new(p) ::RAT::DS::Meta : new ::RAT::DS::Meta;
   }
   static void *newArray_RATcLcLDScLcLMeta(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::Meta[nElements] : new ::RAT::DS::Meta[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMeta(void *p) {
      delete ((::RAT::DS::Meta*)p);
   }
   static void deleteArray_RATcLcLDScLcLMeta(void *p) {
      delete [] ((::RAT::DS::Meta*)p);
   }
   static void destruct_RATcLcLDScLcLMeta(void *p) {
      typedef ::RAT::DS::Meta current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::Meta

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MetaDB::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MetaDB.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MetaDB::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MetaDB::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MetaDB::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MetaDB.
      TClass *R__cl = ::RAT::DS::MetaDB::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "overrides", (void*)&overrides);
      R__insp.InspectMember("vector<std::pair<std::string,std::string> >", (void*)&overrides, "overrides.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "files", (void*)&files);
      R__insp.InspectMember("vector<std::string>", (void*)&files, "files.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMetaDB(void *p) {
      return  p ? new(p) ::RAT::DS::MetaDB : new ::RAT::DS::MetaDB;
   }
   static void *newArray_RATcLcLDScLcLMetaDB(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MetaDB[nElements] : new ::RAT::DS::MetaDB[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMetaDB(void *p) {
      delete ((::RAT::DS::MetaDB*)p);
   }
   static void deleteArray_RATcLcLDScLcLMetaDB(void *p) {
      delete [] ((::RAT::DS::MetaDB*)p);
   }
   static void destruct_RATcLcLDScLcLMetaDB(void *p) {
      typedef ::RAT::DS::MetaDB current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MetaDB

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void PMT<Double32_t>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMT<Double32_t>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMT<Double32_t>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMT<Double32_t>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLPMTlEDouble32_tgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::PMT<Double32_t>.
      typedef ::ROOTShadow::Shadow::RAT::DS::PMTlEDouble32_tgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<Double32_t>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &sobj->id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qhs", &sobj->qhs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qhl", &sobj->qhl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qlx", &sobj->qlx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "time", &sobj->time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "cellID", &sobj->cellID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chanFlags", &sobj->chanFlags);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "isCrossTalk", &sobj->isCrossTalk);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void PMT<Double32_t>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLPMTlEDouble32_tgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) {
      return  p ? new(p) ::RAT::DS::PMT<Double32_t> : new ::RAT::DS::PMT<Double32_t>;
   }
   static void *newArray_RATcLcLDScLcLPMTlEDouble32_tgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMT<Double32_t>[nElements] : new ::RAT::DS::PMT<Double32_t>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) {
      delete ((::RAT::DS::PMT<Double32_t>*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) {
      delete [] ((::RAT::DS::PMT<Double32_t>*)p);
   }
   static void destruct_RATcLcLDScLcLPMTlEDouble32_tgR(void *p) {
      typedef ::RAT::DS::PMT<Double32_t> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMT<Double32_t>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void PMT<unsigned short>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMT<unsigned short>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMT<unsigned short>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMT<unsigned short>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLPMTlEunsignedsPshortgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::PMT<unsigned short>.
      typedef ::ROOTShadow::Shadow::RAT::DS::PMTlEunsignedsPshortgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMT<unsigned short>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &sobj->id);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qhs", &sobj->qhs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qhl", &sobj->qhl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "qlx", &sobj->qlx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "time", &sobj->time);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "cellID", &sobj->cellID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chanFlags", &sobj->chanFlags);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "isCrossTalk", &sobj->isCrossTalk);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void PMT<unsigned short>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLPMTlEunsignedsPshortgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) {
      return  p ? new(p) ::RAT::DS::PMT<unsigned short> : new ::RAT::DS::PMT<unsigned short>;
   }
   static void *newArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMT<unsigned short>[nElements] : new ::RAT::DS::PMT<unsigned short>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) {
      delete ((::RAT::DS::PMT<unsigned short>*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) {
      delete [] ((::RAT::DS::PMT<unsigned short>*)p);
   }
   static void destruct_RATcLcLDScLcLPMTlEunsignedsPshortgR(void *p) {
      typedef ::RAT::DS::PMT<unsigned short> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMT<unsigned short>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void MCHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::MCHit.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::MCHit::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::MCHit::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void MCHit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::MCHit.
      TClass *R__cl = ::RAT::DS::MCHit::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef RAT::DS::PMT<Double32_t> baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLMCHit(void *p) {
      return  p ? new(p) ::RAT::DS::MCHit : new ::RAT::DS::MCHit;
   }
   static void *newArray_RATcLcLDScLcLMCHit(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::MCHit[nElements] : new ::RAT::DS::MCHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLMCHit(void *p) {
      delete ((::RAT::DS::MCHit*)p);
   }
   static void deleteArray_RATcLcLDScLcLMCHit(void *p) {
      delete [] ((::RAT::DS::MCHit*)p);
   }
   static void destruct_RATcLcLDScLcLMCHit(void *p) {
      typedef ::RAT::DS::MCHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::MCHit

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void PMTCal::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMTCal.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMTCal::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMTCal::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void PMTCal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::PMTCal.
      TClass *R__cl = ::RAT::DS::PMTCal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "status", &status);
      R__insp.InspectMember(status, "status.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef RAT::DS::PMT<Double32_t> baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTCal(void *p) {
      return  p ? new(p) ::RAT::DS::PMTCal : new ::RAT::DS::PMTCal;
   }
   static void *newArray_RATcLcLDScLcLPMTCal(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMTCal[nElements] : new ::RAT::DS::PMTCal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTCal(void *p) {
      delete ((::RAT::DS::PMTCal*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTCal(void *p) {
      delete [] ((::RAT::DS::PMTCal*)p);
   }
   static void destruct_RATcLcLDScLcLPMTCal(void *p) {
      typedef ::RAT::DS::PMTCal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMTCal

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void PMTSet<RAT::DS::MCHit>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMTSet<RAT::DS::MCHit>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMTSet<RAT::DS::MCHit>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMTSet<RAT::DS::MCHit>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::PMTSet<RAT::DS::MCHit>.
      typedef ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLMCHitgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::MCHit>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "normal", (void*)&sobj->normal);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->normal, "normal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inward", (void*)&sobj->inward);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->inward, "inward.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "owl", (void*)&sobj->owl);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->owl, "owl.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lowGain", (void*)&sobj->lowGain);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->lowGain, "lowGain.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "butt", (void*)&sobj->butt);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->butt, "butt.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "neck", (void*)&sobj->neck);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->neck, "neck.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fecd", (void*)&sobj->fecd);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->fecd, "fecd.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "spare", (void*)&sobj->spare);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->spare, "spare.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hqe", (void*)&sobj->hqe);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->hqe, "hqe.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "invalid", (void*)&sobj->invalid);
      R__insp.InspectMember("vector<RAT::DS::MCHit>", (void*)&sobj->invalid, "invalid.", false);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void PMTSet<RAT::DS::MCHit>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) {
      return  p ? new(p) ::RAT::DS::PMTSet<RAT::DS::MCHit> : new ::RAT::DS::PMTSet<RAT::DS::MCHit>;
   }
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMTSet<RAT::DS::MCHit>[nElements] : new ::RAT::DS::PMTSet<RAT::DS::MCHit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) {
      delete ((::RAT::DS::PMTSet<RAT::DS::MCHit>*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) {
      delete [] ((::RAT::DS::PMTSet<RAT::DS::MCHit>*)p);
   }
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void *p) {
      typedef ::RAT::DS::PMTSet<RAT::DS::MCHit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMTSet<RAT::DS::MCHit>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void PMTSet<RAT::DS::PMTCal>::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMTSet<RAT::DS::PMTCal>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMTSet<RAT::DS::PMTCal>::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMTSet<RAT::DS::PMTCal>::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::PMTSet<RAT::DS::PMTCal>.
      typedef ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLPMTCalgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "normal", (void*)&sobj->normal);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->normal, "normal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inward", (void*)&sobj->inward);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->inward, "inward.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "owl", (void*)&sobj->owl);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->owl, "owl.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lowGain", (void*)&sobj->lowGain);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->lowGain, "lowGain.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "butt", (void*)&sobj->butt);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->butt, "butt.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "neck", (void*)&sobj->neck);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->neck, "neck.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fecd", (void*)&sobj->fecd);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->fecd, "fecd.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "spare", (void*)&sobj->spare);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->spare, "spare.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hqe", (void*)&sobj->hqe);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->hqe, "hqe.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "invalid", (void*)&sobj->invalid);
      R__insp.InspectMember("vector<RAT::DS::PMTCal>", (void*)&sobj->invalid, "invalid.", false);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void PMTSet<RAT::DS::PMTCal>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) {
      return  p ? new(p) ::RAT::DS::PMTSet<RAT::DS::PMTCal> : new ::RAT::DS::PMTSet<RAT::DS::PMTCal>;
   }
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMTSet<RAT::DS::PMTCal>[nElements] : new ::RAT::DS::PMTSet<RAT::DS::PMTCal>[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) {
      delete ((::RAT::DS::PMTSet<RAT::DS::PMTCal>*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) {
      delete [] ((::RAT::DS::PMTSet<RAT::DS::PMTCal>*)p);
   }
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void *p) {
      typedef ::RAT::DS::PMTSet<RAT::DS::PMTCal> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMTSet<RAT::DS::PMTCal>

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
template <> void PMTSet<RAT::DS::PMT<unsigned short> >::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >.
      typedef ::ROOTShadow::Shadow::RAT::DS::PMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "normal", (void*)&sobj->normal);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->normal, "normal.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "inward", (void*)&sobj->inward);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->inward, "inward.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "owl", (void*)&sobj->owl);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->owl, "owl.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lowGain", (void*)&sobj->lowGain);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->lowGain, "lowGain.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "butt", (void*)&sobj->butt);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->butt, "butt.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "neck", (void*)&sobj->neck);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->neck, "neck.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fecd", (void*)&sobj->fecd);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->fecd, "fecd.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "spare", (void*)&sobj->spare);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->spare, "spare.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "hqe", (void*)&sobj->hqe);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->hqe, "hqe.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "invalid", (void*)&sobj->invalid);
      R__insp.InspectMember("vector<RAT::DS::PMT<unsigned short> >", (void*)&sobj->invalid, "invalid.", false);
      sobj->TObject::ShowMembers(R__insp);
   }

}

      namespace RAT {
         namespace DS {
template <> void PMTSet<RAT::DS::PMT<unsigned short> >::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOTDict::RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_ShowMembers(this, R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      return  p ? new(p) ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > : new ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >;
   }
   static void *newArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >[nElements] : new ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      delete ((::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)p);
   }
   static void deleteArray_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      delete [] ((::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)p);
   }
   static void destruct_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      typedef ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void Run::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::Run.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::Run::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::Run::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void Run::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::Run.
      TClass *R__cl = ::RAT::DS::Run::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "socs", (void*)&socs);
      R__insp.InspectMember("map<std::string,SOC>", (void*)&socs, "socs.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "digitiserTrigSums", (void*)&digitiserTrigSums);
      R__insp.InspectMember("vector<int>", (void*)&digitiserTrigSums, "digitiserTrigSums.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "builderVersion", (void*)&builderVersion);
      R__insp.InspectMember("string", (void*)&builderVersion, "builderVersion.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "chanSWStatus", (void*)&chanSWStatus);
      R__insp.InspectMember("map<UInt_t,BitMask>", (void*)&chanSWStatus, "chanSWStatus.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dataQualityFlags", &dataQualityFlags);
      R__insp.InspectMember(dataQualityFlags, "dataQualityFlags.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "runID", &runID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "subRunID", &subRunID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "date", &date);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "startTime", &startTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "runType", &runType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "firstGTID", &firstGTID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "validGTID", &validGTID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nMCEvents", &nMCEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "mcFlag", &mcFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "runLength", &runLength);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLRun(void *p) {
      return  p ? new(p) ::RAT::DS::Run : new ::RAT::DS::Run;
   }
   static void *newArray_RATcLcLDScLcLRun(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::Run[nElements] : new ::RAT::DS::Run[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLRun(void *p) {
      delete ((::RAT::DS::Run*)p);
   }
   static void deleteArray_RATcLcLDScLcLRun(void *p) {
      delete [] ((::RAT::DS::Run*)p);
   }
   static void destruct_RATcLcLDScLcLRun(void *p) {
      typedef ::RAT::DS::Run current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::Run

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void SOC::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::SOC.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::SOC::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::SOC::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void SOC::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::SOC.
      TClass *R__cl = ::RAT::DS::SOC::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pmts", (void*)&pmts);
      R__insp.InspectMember("map<UInt_t,SOCPMT>", (void*)&pmts, "pmts.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fitResults", (void*)&fitResults);
      R__insp.InspectMember("map<string,RAT::DS::FitResult,less<string>,allocator<pair<const string,RAT::DS::FitResult> > >", (void*)&fitResults, "fitResults.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "globalTimeOffset", &globalTimeOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nPulsesTriggered", &nPulsesTriggered);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "calib", &calib);
      R__insp.InspectMember(calib, "calib.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "sourceID", (void*)&sourceID);
      R__insp.InspectMember("string", (void*)&sourceID, "sourceID.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "runID", &runID);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLSOC(void *p) {
      return  p ? new(p) ::RAT::DS::SOC : new ::RAT::DS::SOC;
   }
   static void *newArray_RATcLcLDScLcLSOC(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::SOC[nElements] : new ::RAT::DS::SOC[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLSOC(void *p) {
      delete ((::RAT::DS::SOC*)p);
   }
   static void deleteArray_RATcLcLDScLcLSOC(void *p) {
      delete [] ((::RAT::DS::SOC*)p);
   }
   static void destruct_RATcLcLDScLcLSOC(void *p) {
      typedef ::RAT::DS::SOC current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::SOC

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void SOCPMT::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::SOCPMT.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::SOCPMT::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::SOCPMT::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void SOCPMT::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::SOCPMT.
      TClass *R__cl = ::RAT::DS::SOCPMT::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "TACs", (void*)&TACs);
      R__insp.InspectMember("vector<Float_t>", (void*)&TACs, "TACs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "QHLs", (void*)&QHLs);
      R__insp.InspectMember("vector<Float_t>", (void*)&QHLs, "QHLs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "QHSs", (void*)&QHSs);
      R__insp.InspectMember("vector<Float_t>", (void*)&QHSs, "QHSs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lcn", &lcn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "manipTimeOfFlight", &manipTimeOfFlight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "promptOccupancy", &promptOccupancy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tacCentroid", &tacCentroid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tacError", &tacError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "peakFindOk", &peakFindOk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "shadowRelativeOccupancy", &shadowRelativeOccupancy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ropeShadowRelativeOccupancy", &ropeShadowRelativeOccupancy);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLSOCPMT(void *p) {
      return  p ? new(p) ::RAT::DS::SOCPMT : new ::RAT::DS::SOCPMT;
   }
   static void *newArray_RATcLcLDScLcLSOCPMT(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::SOCPMT[nElements] : new ::RAT::DS::SOCPMT[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLSOCPMT(void *p) {
      delete ((::RAT::DS::SOCPMT*)p);
   }
   static void deleteArray_RATcLcLDScLcLSOCPMT(void *p) {
      delete [] ((::RAT::DS::SOCPMT*)p);
   }
   static void destruct_RATcLcLDScLcLSOCPMT(void *p) {
      typedef ::RAT::DS::SOCPMT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::SOCPMT

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void TrigHeader::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::TrigHeader.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::TrigHeader::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::TrigHeader::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void TrigHeader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::TrigHeader.
      TClass *R__cl = ::RAT::DS::TrigHeader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "thresholds", (void*)&thresholds);
      R__insp.InspectMember("map<UShort_t,UShort_t>", (void*)&thresholds, "thresholds.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "offsets", (void*)&offsets);
      R__insp.InspectMember("map<UShort_t,UShort_t>", (void*)&offsets, "offsets.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "trigMask", &trigMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pulserRate", &pulserRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "MTC_CSR", &MTC_CSR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "lockoutWidth", &lockoutWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "prescaleFrequency", &prescaleFrequency);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLTrigHeader(void *p) {
      return  p ? new(p) ::RAT::DS::TrigHeader : new ::RAT::DS::TrigHeader;
   }
   static void *newArray_RATcLcLDScLcLTrigHeader(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::TrigHeader[nElements] : new ::RAT::DS::TrigHeader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLTrigHeader(void *p) {
      delete ((::RAT::DS::TrigHeader*)p);
   }
   static void deleteArray_RATcLcLDScLcLTrigHeader(void *p) {
      delete [] ((::RAT::DS::TrigHeader*)p);
   }
   static void destruct_RATcLcLDScLcLTrigHeader(void *p) {
      typedef ::RAT::DS::TrigHeader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::TrigHeader

      namespace RAT {
         namespace DS {
//______________________________________________________________________________
void UniversalTime::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DS::UniversalTime.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DS::UniversalTime::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DS::UniversalTime::Class(),this);
   }
}

} // namespace RAT::DS
} // namespace RAT::DS
//______________________________________________________________________________
      namespace RAT {
         namespace DS {
void UniversalTime::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DS::UniversalTime.
      TClass *R__cl = ::RAT::DS::UniversalTime::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "days", &days);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "seconds", &seconds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "nanoSeconds", &nanoSeconds);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DS
} // namespace RAT::DS
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDScLcLUniversalTime(void *p) {
      return  p ? new(p) ::RAT::DS::UniversalTime : new ::RAT::DS::UniversalTime;
   }
   static void *newArray_RATcLcLDScLcLUniversalTime(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DS::UniversalTime[nElements] : new ::RAT::DS::UniversalTime[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLUniversalTime(void *p) {
      delete ((::RAT::DS::UniversalTime*)p);
   }
   static void deleteArray_RATcLcLDScLcLUniversalTime(void *p) {
      delete [] ((::RAT::DS::UniversalTime*)p);
   }
   static void destruct_RATcLcLDScLcLUniversalTime(void *p) {
      typedef ::RAT::DS::UniversalTime current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::UniversalTime

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLCartesian3DlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::Cartesian3D<float>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::Cartesian3DlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::Cartesian3D<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &sobj->fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &sobj->fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &sobj->fZ);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Cartesian3D<float> : new ::ROOT::Math::Cartesian3D<float>;
   }
   static void *newArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Cartesian3D<float>[nElements] : new ::ROOT::Math::Cartesian3D<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) {
      delete ((::ROOT::Math::Cartesian3D<float>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) {
      delete [] ((::ROOT::Math::Cartesian3D<float>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLCartesian3DlEfloatgR(void *p) {
      typedef ::ROOT::Math::Cartesian3D<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::Cartesian3D<float>

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinates", (void*)&sobj->fCoordinates);
      R__insp.InspectMember("ROOT::Math::Cartesian3D<double>", (void*)&sobj->fCoordinates, "fCoordinates.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
   }
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete [] ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      typedef ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinates", (void*)&sobj->fCoordinates);
      R__insp.InspectMember("ROOT::Math::Cartesian3D<float>", (void*)&sobj->fCoordinates, "fCoordinates.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
   }
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete [] ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      typedef ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLPolar3DlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::Polar3D<float>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::Polar3DlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::Polar3D<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR", &sobj->fR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &sobj->fTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &sobj->fPhi);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Polar3D<float> : new ::ROOT::Math::Polar3D<float>;
   }
   static void *newArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Polar3D<float>[nElements] : new ::ROOT::Math::Polar3D<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) {
      delete ((::ROOT::Math::Polar3D<float>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) {
      delete [] ((::ROOT::Math::Polar3D<float>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLPolar3DlEfloatgR(void *p) {
      typedef ::ROOT::Math::Polar3D<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::Polar3D<float>

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinates", (void*)&sobj->fCoordinates);
      R__insp.InspectMember("ROOT::Math::Polar3D<double>", (void*)&sobj->fCoordinates, "fCoordinates.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
   }
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete [] ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      typedef ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>

//______________________________________________________________________________
namespace ROOTDict {
   void ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>.
      typedef ::ROOTShadow::Shadow::ROOT::Math::DisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoordinates", (void*)&sobj->fCoordinates);
      R__insp.InspectMember("ROOT::Math::Polar3D<float>", (void*)&sobj->fCoordinates, "fCoordinates.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
   }
   static void *newArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[nElements] : new ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void deleteArray_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      delete [] ((::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)p);
   }
   static void destruct_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void *p) {
      typedef ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLTrackNav(void *p) {
      delete ((::RAT::TrackNav*)p);
   }
   static void deleteArray_RATcLcLTrackNav(void *p) {
      delete [] ((::RAT::TrackNav*)p);
   }
   static void destruct_RATcLcLTrackNav(void *p) {
      typedef ::RAT::TrackNav current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::TrackNav

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLTrackCursor(void *p) {
      delete ((::RAT::TrackCursor*)p);
   }
   static void deleteArray_RATcLcLTrackCursor(void *p) {
      delete [] ((::RAT::TrackCursor*)p);
   }
   static void destruct_RATcLcLTrackCursor(void *p) {
      typedef ::RAT::TrackCursor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::TrackCursor

      namespace RAT {
//______________________________________________________________________________
void TrackNode::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::TrackNode.

   //This works around a msvc bug and should be harmless on other platforms
   typedef ::RAT::TrackNode thisClass;
   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef RAT::DS::MCTrackStep baseClass0;
      baseClass0::Streamer(R__b);
      {
         vector<TrackNode*> &R__stl =  fChild;
         R__stl.clear();
         TClass *R__tcl1 = TBuffer::GetClass(typeid(RAT::TrackNode));
         if (R__tcl1==0) {
            Error("fChild streamer","Missing the TClass object for RAT::TrackNode!");
            return;
         }
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            RAT::TrackNode* R__t;
            R__t = (RAT::TrackNode*)R__b.ReadObjectAny(R__tcl1);
            R__stl.push_back(R__t);
         }
      }
      R__b >> fIsTrackStart;
      R__b >> fTrackID;
      R__b >> fStepID;
      R__b >> fPDGCode;
      { TString R__str; R__str.Streamer(R__b); fParticleName = R__str.Data(); }
      R__b >> fPrev;
      R__b >> fNext;
      R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
   } else {
      R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RAT::DS::MCTrackStep baseClass0;
      baseClass0::Streamer(R__b);
      {
         vector<TrackNode*> &R__stl =  fChild;
         int R__n=(true) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<TrackNode*>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b << fIsTrackStart;
      R__b << fTrackID;
      R__b << fStepID;
      R__b << fPDGCode;
      { TString R__str = fParticleName.c_str(); R__str.Streamer(R__b);}
      R__b << fPrev;
      R__b << fNext;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

} // namespace RAT
//______________________________________________________________________________
      namespace RAT {
void TrackNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::TrackNode.
      TClass *R__cl = ::RAT::TrackNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChild", (void*)&fChild);
      R__insp.InspectMember("vector<TrackNode*>", (void*)&fChild, "fChild.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTrackStart", &fIsTrackStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrackID", &fTrackID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepID", &fStepID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDGCode", &fPDGCode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParticleName", (void*)&fParticleName);
      R__insp.InspectMember("string", (void*)&fParticleName, "fParticleName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrev", &fPrev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNext", &fNext);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RAT::DS::MCTrackStep baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RAT
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLTrackNode(void *p) {
      return  p ? new(p) ::RAT::TrackNode : new ::RAT::TrackNode;
   }
   static void *newArray_RATcLcLTrackNode(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::TrackNode[nElements] : new ::RAT::TrackNode[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLTrackNode(void *p) {
      delete ((::RAT::TrackNode*)p);
   }
   static void deleteArray_RATcLcLTrackNode(void *p) {
      delete [] ((::RAT::TrackNode*)p);
   }
   static void destruct_RATcLcLTrackNode(void *p) {
      typedef ::RAT::TrackNode current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLTrackNode(TBuffer &buf, void *obj) {
      ((::RAT::TrackNode*)obj)->::RAT::TrackNode::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::TrackNode

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLPgSQLBackend_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::PgSQLBackend.
      typedef ::ROOTShadow::Shadow::RAT::PgSQLBackend ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::PgSQLBackend*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*pg_conn_", &sobj->pg_conn_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*pg_res_", &sobj->pg_res_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*pg_notify_", &sobj->pg_notify_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "server_url_", (void*)&sobj->server_url_);
      R__insp.InspectMember("string", (void*)&sobj->server_url_, "server_url_.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "conn_options_", (void*)&sobj->conn_options_);
      R__insp.InspectMember("string", (void*)&sobj->conn_options_, "conn_options_.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "num_reconn_", &sobj->num_reconn_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "num_sec_wait_", &sobj->num_sec_wait_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bor_done_", &sobj->bor_done_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bor_warn_given_", &sobj->bor_warn_given_);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ratdb_tag_", (void*)&sobj->ratdb_tag_);
      R__insp.InspectMember("string", (void*)&sobj->ratdb_tag_, "ratdb_tag_.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ratdb_header_tbl_", (void*)&sobj->ratdb_header_tbl_);
      R__insp.InspectMember("string", (void*)&sobj->ratdb_header_tbl_, "ratdb_header_tbl_.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLPgSQLBackend(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::PgSQLBackend : new ::RAT::PgSQLBackend;
   }
   static void *newArray_RATcLcLPgSQLBackend(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::PgSQLBackend[nElements] : new ::RAT::PgSQLBackend[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLPgSQLBackend(void *p) {
      delete ((::RAT::PgSQLBackend*)p);
   }
   static void deleteArray_RATcLcLPgSQLBackend(void *p) {
      delete [] ((::RAT::PgSQLBackend*)p);
   }
   static void destruct_RATcLcLPgSQLBackend(void *p) {
      typedef ::RAT::PgSQLBackend current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::PgSQLBackend

      namespace RAT {
//______________________________________________________________________________
void DB::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DB.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DB::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DB::Class(),this);
   }
}

} // namespace RAT
//______________________________________________________________________________
      namespace RAT {
void DB::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DB.
      TClass *R__cl = ::RAT::DB::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllowDanger", &fAllowDanger);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllowDangerWhitelist", (void*)&fAllowDangerWhitelist);
      R__insp.InspectMember("vector<std::string>", (void*)&fAllowDangerWhitelist, "fAllowDangerWhitelist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPassMap", (void*)&fPassMap);
      R__insp.InspectMember("map<std::pair<std::string,std::string>,int>", (void*)&fPassMap, "fPassMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "links", (void*)&links);
      R__insp.InspectMember("list<RAT::DBLink*>", (void*)&links, "links.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "server", (void*)&server);
      R__insp.InspectMember("string", (void*)&server, "server.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tableNamesOnServer", (void*)&tableNamesOnServer);
      R__insp.InspectMember("set<std::string>", (void*)&tableNamesOnServer, "tableNamesOnServer.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tablesNotOnServer", (void*)&tablesNotOnServer);
      R__insp.InspectMember("set<RAT::DBTableKey>", (void*)&tablesNotOnServer, "tablesNotOnServer.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDbBackend", &fDbBackend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tables_default", (void*)&tables_default);
      R__insp.InspectMember("RAT::DBTableSet", (void*)&tables_default, "tables_default.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tables_user", (void*)&tables_user);
      R__insp.InspectMember("RAT::DBTableSet", (void*)&tables_user, "tables_user.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tables_run", (void*)&tables_run);
      R__insp.InspectMember("RAT::DBTableSet", (void*)&tables_run, "tables_run.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tablesFromServer", (void*)&tablesFromServer);
      R__insp.InspectMember("deque<RAT::DBTableKey>", (void*)&tablesFromServer, "tablesFromServer.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRunID", &fRunID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTblNoDefaultPlane", (void*)&fTblNoDefaultPlane);
      R__insp.InspectMember("vector<std::pair<std::string,std::string> >", (void*)&fTblNoDefaultPlane, "fTblNoDefaultPlane.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTblNoDefaultPlaneUser", (void*)&fTblNoDefaultPlaneUser);
      R__insp.InspectMember("vector<std::pair<std::string,std::string> >", (void*)&fTblNoDefaultPlaneUser, "fTblNoDefaultPlaneUser.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTblNoDefaultPlaneExceptions", (void*)&fTblNoDefaultPlaneExceptions);
      R__insp.InspectMember("vector<std::string>", (void*)&fTblNoDefaultPlaneExceptions, "fTblNoDefaultPlaneExceptions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileList", (void*)&fFileList);
      R__insp.InspectMember("set<std::string>", (void*)&fFileList, "fFileList.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDbTag", (void*)&fDbTag);
      R__insp.InspectMember("string", (void*)&fDbTag, "fDbTag.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAirplaneMode", &fAirplaneMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultPlaneLockEnabled", &fDefaultPlaneLockEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultsLoaded", &fDefaultsLoaded);
}

} // namespace RAT
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDB(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DB : new ::RAT::DB;
   }
   static void *newArray_RATcLcLDB(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DB[nElements] : new ::RAT::DB[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDB(void *p) {
      delete ((::RAT::DB*)p);
   }
   static void deleteArray_RATcLcLDB(void *p) {
      delete [] ((::RAT::DB*)p);
   }
   static void destruct_RATcLcLDB(void *p) {
      typedef ::RAT::DB current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DB

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDBLink_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DBLink.
      typedef ::ROOTShadow::Shadow::RAT::DBLink ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBLink*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*db", &sobj->db);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tblname", (void*)&sobj->tblname);
      R__insp.InspectMember("string", (void*)&sobj->tblname, "tblname.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "index", (void*)&sobj->index);
      R__insp.InspectMember("string", (void*)&sobj->index, "index.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "currentRun", &sobj->currentRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "loadFromDefaultPlane", &sobj->loadFromDefaultPlane);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pass", &sobj->pass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "validVersion", &sobj->validVersion);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLDBLink(void *p) {
      delete ((::RAT::DBLink*)p);
   }
   static void deleteArray_RATcLcLDBLink(void *p) {
      delete [] ((::RAT::DBLink*)p);
   }
   static void destruct_RATcLcLDBLink(void *p) {
      typedef ::RAT::DBLink current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DBLink

//______________________________________________________________________________
namespace ROOTDict {
   void simple_ptr_nocopylERATcLcLDBLinkgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class simple_ptr_nocopy<RAT::DBLink>.
      typedef ::ROOTShadow::Shadow::simple_ptr_nocopylERATcLcLDBLinkgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBLink>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_pointer", &sobj->m_pointer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_count", &sobj->m_count);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_simple_ptr_nocopylERATcLcLDBLinkgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::simple_ptr_nocopy<RAT::DBLink> : new ::simple_ptr_nocopy<RAT::DBLink>;
   }
   static void *newArray_simple_ptr_nocopylERATcLcLDBLinkgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::simple_ptr_nocopy<RAT::DBLink>[nElements] : new ::simple_ptr_nocopy<RAT::DBLink>[nElements];
   }
   // Wrapper around operator delete
   static void delete_simple_ptr_nocopylERATcLcLDBLinkgR(void *p) {
      delete ((::simple_ptr_nocopy<RAT::DBLink>*)p);
   }
   static void deleteArray_simple_ptr_nocopylERATcLcLDBLinkgR(void *p) {
      delete [] ((::simple_ptr_nocopy<RAT::DBLink>*)p);
   }
   static void destruct_simple_ptr_nocopylERATcLcLDBLinkgR(void *p) {
      typedef ::simple_ptr_nocopy<RAT::DBLink> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::simple_ptr_nocopy<RAT::DBLink>

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDBTable_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DBTable.
      typedef ::ROOTShadow::Shadow::RAT::DBTable ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBTable*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tblname", (void*)&sobj->tblname);
      R__insp.InspectMember("string", (void*)&sobj->tblname, "tblname.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "index", (void*)&sobj->index);
      R__insp.InspectMember("string", (void*)&sobj->index, "index.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "run_begin", &sobj->run_begin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "run_end", &sobj->run_end);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "pass_number", &sobj->pass_number);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "bytes", &sobj->bytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "table", (void*)&sobj->table);
      R__insp.InspectMember("json::Value", (void*)&sobj->table, "table.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "arrayTypeCache", (void*)&sobj->arrayTypeCache);
      R__insp.InspectMember("stlplus::hash<string,RAT::DBTable::FieldType,RAT::pyhash,equal_to<string> >", (void*)&sobj->arrayTypeCache, "arrayTypeCache.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDBTable(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBTable : new ::RAT::DBTable;
   }
   static void *newArray_RATcLcLDBTable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBTable[nElements] : new ::RAT::DBTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDBTable(void *p) {
      delete ((::RAT::DBTable*)p);
   }
   static void deleteArray_RATcLcLDBTable(void *p) {
      delete [] ((::RAT::DBTable*)p);
   }
   static void destruct_RATcLcLDBTable(void *p) {
      typedef ::RAT::DBTable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DBTable

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDBTextLoader_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DBTextLoader.
      typedef ::ROOTShadow::Shadow::RAT::DBTextLoader ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBTextLoader*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDBTextLoader(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBTextLoader : new ::RAT::DBTextLoader;
   }
   static void *newArray_RATcLcLDBTextLoader(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBTextLoader[nElements] : new ::RAT::DBTextLoader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDBTextLoader(void *p) {
      delete ((::RAT::DBTextLoader*)p);
   }
   static void deleteArray_RATcLcLDBTextLoader(void *p) {
      delete [] ((::RAT::DBTextLoader*)p);
   }
   static void destruct_RATcLcLDBTextLoader(void *p) {
      typedef ::RAT::DBTextLoader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DBTextLoader

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDBCommandLoader_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DBCommandLoader.
      typedef ::ROOTShadow::Shadow::RAT::DBCommandLoader ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBCommandLoader*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDBCommandLoader(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBCommandLoader : new ::RAT::DBCommandLoader;
   }
   static void *newArray_RATcLcLDBCommandLoader(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBCommandLoader[nElements] : new ::RAT::DBCommandLoader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDBCommandLoader(void *p) {
      delete ((::RAT::DBCommandLoader*)p);
   }
   static void deleteArray_RATcLcLDBCommandLoader(void *p) {
      delete [] ((::RAT::DBCommandLoader*)p);
   }
   static void destruct_RATcLcLDBCommandLoader(void *p) {
      typedef ::RAT::DBCommandLoader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DBCommandLoader

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLMetaInformation_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::MetaInformation.
      typedef ::ROOTShadow::Shadow::RAT::MetaInformation ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::MetaInformation*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeta", &sobj->fMeta);
      R__insp.InspectMember(sobj->fMeta, "fMeta.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLMetaInformation(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::MetaInformation( (TRootIOCtor*)0 ) : new ::RAT::MetaInformation( (TRootIOCtor*)0 );
   }
   // Wrapper around operator delete
   static void delete_RATcLcLMetaInformation(void *p) {
      delete ((::RAT::MetaInformation*)p);
   }
   static void deleteArray_RATcLcLMetaInformation(void *p) {
      delete [] ((::RAT::MetaInformation*)p);
   }
   static void destruct_RATcLcLMetaInformation(void *p) {
      typedef ::RAT::MetaInformation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::MetaInformation

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDBJsonLoader_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DBJsonLoader.
      typedef ::ROOTShadow::Shadow::RAT::DBJsonLoader ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DBJsonLoader*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDBJsonLoader(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBJsonLoader : new ::RAT::DBJsonLoader;
   }
   static void *newArray_RATcLcLDBJsonLoader(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DBJsonLoader[nElements] : new ::RAT::DBJsonLoader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDBJsonLoader(void *p) {
      delete ((::RAT::DBJsonLoader*)p);
   }
   static void deleteArray_RATcLcLDBJsonLoader(void *p) {
      delete [] ((::RAT::DBJsonLoader*)p);
   }
   static void destruct_RATcLcLDBJsonLoader(void *p) {
      typedef ::RAT::DBJsonLoader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DBJsonLoader

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_jsoncLcLValue(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::json::Value : new ::json::Value;
   }
   static void *newArray_jsoncLcLValue(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::json::Value[nElements] : new ::json::Value[nElements];
   }
   // Wrapper around operator delete
   static void delete_jsoncLcLValue(void *p) {
      delete ((::json::Value*)p);
   }
   static void deleteArray_jsoncLcLValue(void *p) {
      delete [] ((::json::Value*)p);
   }
   static void destruct_jsoncLcLValue(void *p) {
      typedef ::json::Value current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::json::Value

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLog_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::Log.
      typedef ::ROOTShadow::Shadow::RAT::Log ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::Log*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLLog(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::Log( (TRootIOCtor*)0 ) : new ::RAT::Log( (TRootIOCtor*)0 );
   }
   // Wrapper around operator delete
   static void delete_RATcLcLLog(void *p) {
      delete ((::RAT::Log*)p);
   }
   static void deleteArray_RATcLcLLog(void *p) {
      delete [] ((::RAT::Log*)p);
   }
   static void destruct_RATcLcLLog(void *p) {
      typedef ::RAT::Log current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::Log

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLHTTPDownloader_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::HTTPDownloader.
      typedef ::ROOTShadow::Shadow::RAT::HTTPDownloader ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::HTTPDownloader*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*handle", &sobj->handle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "noproxy_set", &sobj->noproxy_set);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "contents", (void*)&sobj->contents);
      R__insp.InspectMember("ostringstream", (void*)&sobj->contents, "contents.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLHTTPDownloader(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::HTTPDownloader : new ::RAT::HTTPDownloader;
   }
   static void *newArray_RATcLcLHTTPDownloader(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::HTTPDownloader[nElements] : new ::RAT::HTTPDownloader[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLHTTPDownloader(void *p) {
      delete ((::RAT::HTTPDownloader*)p);
   }
   static void deleteArray_RATcLcLHTTPDownloader(void *p) {
      delete [] ((::RAT::HTTPDownloader*)p);
   }
   static void destruct_RATcLcLHTTPDownloader(void *p) {
      typedef ::RAT::HTTPDownloader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::HTTPDownloader

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void DSReader::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::DSReader.

   //This works around a msvc bug and should be harmless on other platforms
   typedef ::RAT::DU::DSReader thisClass;
   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> fT;
      R__b >> fRunT;
      R__b >> fDS;
      R__b >> fRun;
      R__b >> fMeta;
      R__b >> fCurrentEntry;
      R__b >> fTotalEntries;
      R__b >> fCurrentRun;
      R__b >> fTotalRuns;
      R__b >> fUseMeta;
      R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
   } else {
      R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << fT;
      R__b << fRunT;
      R__b << fDS;
      R__b << fRun;
      R__b << fMeta;
      R__b << fCurrentEntry;
      R__b << fTotalEntries;
      R__b << fCurrentRun;
      R__b << fTotalRuns;
      R__b << fUseMeta;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void DSReader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::DSReader.
      TClass *R__cl = ::RAT::DU::DSReader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fT", &fT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRunT", &fRunT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDS", &fDS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRun", &fRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMeta", &fMeta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentEntry", &fCurrentEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalEntries", &fTotalEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentRun", &fCurrentRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalRuns", &fTotalRuns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMeta", &fUseMeta);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLDSReader(void *p) {
      delete ((::RAT::DU::DSReader*)p);
   }
   static void deleteArray_RATcLcLDUcLcLDSReader(void *p) {
      delete [] ((::RAT::DU::DSReader*)p);
   }
   static void destruct_RATcLcLDUcLcLDSReader(void *p) {
      typedef ::RAT::DU::DSReader current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLDSReader(TBuffer &buf, void *obj) {
      ((::RAT::DU::DSReader*)obj)->::RAT::DU::DSReader::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::DSReader

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void SOCReader::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::SOCReader.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void SOCReader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::SOCReader.
      TClass *R__cl = ::RAT::DU::SOCReader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fT", &fT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRunT", &fRunT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSOC", &fSOC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRun", &fRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentSOC", &fCurrentSOC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalSOC", &fTotalSOC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentRun", &fCurrentRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalRuns", &fTotalRuns);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMeta", &fUseMeta);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLSOCReader(void *p) {
      delete ((::RAT::DU::SOCReader*)p);
   }
   static void deleteArray_RATcLcLDUcLcLSOCReader(void *p) {
      delete [] ((::RAT::DU::SOCReader*)p);
   }
   static void destruct_RATcLcLDUcLcLSOCReader(void *p) {
      typedef ::RAT::DU::SOCReader current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLSOCReader(TBuffer &buf, void *obj) {
      ((::RAT::DU::SOCReader*)obj)->::RAT::DU::SOCReader::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::SOCReader

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void Utility::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::Utility.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void Utility::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::Utility.
      TClass *R__cl = ::RAT::DU::Utility::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMTInfo", &fPMTInfo);
      R__insp.InspectMember(fPMTInfo, "fPMTInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPanelInfo", &fPanelInfo);
      R__insp.InspectMember(fPanelInfo, "fPanelInfo.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanHWStatus", &fChanHWStatus);
      R__insp.InspectMember(fChanHWStatus, "fChanHWStatus.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMTCalStatus", &fPMTCalStatus);
      R__insp.InspectMember(fPMTCalStatus, "fPMTCalStatus.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReactorNuOsc", (void*)&fReactorNuOsc);
      R__insp.InspectMember("RAT::DU::ReactorNuOsc", (void*)&fReactorNuOsc, "fReactorNuOsc.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSegmentor", &fSegmentor);
      R__insp.InspectMember(fSegmentor, "fSegmentor.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightPathCalculator", &fLightPathCalculator);
      R__insp.InspectMember(fLightPathCalculator, "fLightPathCalculator.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupVelocity", &fGroupVelocity);
      R__insp.InspectMember(fGroupVelocity, "fGroupVelocity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffectiveVelocity", &fEffectiveVelocity);
      R__insp.InspectMember(fEffectiveVelocity, "fEffectiveVelocity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataCleaningBits", &fDataCleaningBits);
      R__insp.InspectMember(fDataCleaningBits, "fDataCleaningBits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataQualityBits", &fDataQualityBits);
      R__insp.InspectMember(fDataQualityBits, "fDataQualityBits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChanSWStatus", &fChanSWStatus);
      R__insp.InspectMember(fChanSWStatus, "fChanSWStatus.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrigBits", &fTrigBits);
      R__insp.InspectMember(fTrigBits, "fTrigBits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShadowingCalculator", (void*)&fShadowingCalculator);
      R__insp.InspectMember("RAT::DU::ShadowingCalculator", (void*)&fShadowingCalculator, "fShadowingCalculator.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReconCorrector", (void*)&fReconCorrector);
      R__insp.InspectMember("RAT::DU::ReconCorrector", (void*)&fReconCorrector, "fReconCorrector.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReconCalibrator", (void*)&fReconCalibrator);
      R__insp.InspectMember("RAT::DU::ReconCalibrator", (void*)&fReconCalibrator, "fReconCalibrator.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeResidualCalculator", &fTimeResidualCalculator);
      R__insp.InspectMember(fTimeResidualCalculator, "fTimeResidualCalculator.");
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLUtility(void *p) {
      return  p ? new(p) ::RAT::DU::Utility( (TRootIOCtor*)0 ) : new ::RAT::DU::Utility( (TRootIOCtor*)0 );
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLUtility(void *p) {
      delete ((::RAT::DU::Utility*)p);
   }
   static void deleteArray_RATcLcLDUcLcLUtility(void *p) {
      delete [] ((::RAT::DU::Utility*)p);
   }
   static void destruct_RATcLcLDUcLcLUtility(void *p) {
      typedef ::RAT::DU::Utility current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLUtility(TBuffer &buf, void *obj) {
      ((::RAT::DU::Utility*)obj)->::RAT::DU::Utility::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::Utility

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void DataCleaningBits::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::DataCleaningBits.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void DataCleaningBits::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::DataCleaningBits.
      TClass *R__cl = ::RAT::DU::DataCleaningBits::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitMap", (void*)&fBitMap);
      R__insp.InspectMember("map<std::string,size_t>", (void*)&fBitMap, "fBitMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInverseBitMap", (void*)&fInverseBitMap);
      R__insp.InspectMember("map<size_t,std::string>", (void*)&fInverseBitMap, "fInverseBitMap.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLDataCleaningBits(void *p) {
      return  p ? new(p) ::RAT::DU::DataCleaningBits : new ::RAT::DU::DataCleaningBits;
   }
   static void *newArray_RATcLcLDUcLcLDataCleaningBits(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::DataCleaningBits[nElements] : new ::RAT::DU::DataCleaningBits[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLDataCleaningBits(void *p) {
      delete ((::RAT::DU::DataCleaningBits*)p);
   }
   static void deleteArray_RATcLcLDUcLcLDataCleaningBits(void *p) {
      delete [] ((::RAT::DU::DataCleaningBits*)p);
   }
   static void destruct_RATcLcLDUcLcLDataCleaningBits(void *p) {
      typedef ::RAT::DU::DataCleaningBits current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLDataCleaningBits(TBuffer &buf, void *obj) {
      ((::RAT::DU::DataCleaningBits*)obj)->::RAT::DU::DataCleaningBits::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::DataCleaningBits

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void DataQualityBits::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::DataQualityBits.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void DataQualityBits::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::DataQualityBits.
      TClass *R__cl = ::RAT::DU::DataQualityBits::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitMap", (void*)&fBitMap);
      R__insp.InspectMember("map<std::string,size_t>", (void*)&fBitMap, "fBitMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInverseBitMap", (void*)&fInverseBitMap);
      R__insp.InspectMember("map<size_t,std::string>", (void*)&fInverseBitMap, "fInverseBitMap.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLDataQualityBits(void *p) {
      return  p ? new(p) ::RAT::DU::DataQualityBits : new ::RAT::DU::DataQualityBits;
   }
   static void *newArray_RATcLcLDUcLcLDataQualityBits(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::DataQualityBits[nElements] : new ::RAT::DU::DataQualityBits[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLDataQualityBits(void *p) {
      delete ((::RAT::DU::DataQualityBits*)p);
   }
   static void deleteArray_RATcLcLDUcLcLDataQualityBits(void *p) {
      delete [] ((::RAT::DU::DataQualityBits*)p);
   }
   static void destruct_RATcLcLDUcLcLDataQualityBits(void *p) {
      typedef ::RAT::DU::DataQualityBits current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLDataQualityBits(TBuffer &buf, void *obj) {
      ((::RAT::DU::DataQualityBits*)obj)->::RAT::DU::DataQualityBits::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::DataQualityBits

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void ChanSWStatus::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::ChanSWStatus.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void ChanSWStatus::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::ChanSWStatus.
      TClass *R__cl = ::RAT::DU::ChanSWStatus::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "channelMask", (void*)&channelMask);
      R__insp.InspectMember("vector<int>", (void*)&channelMask, "channelMask.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdefaultCSS", &fdefaultCSS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResultExist", &fResultExist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBitMap", (void*)&fBitMap);
      R__insp.InspectMember("map<std::string,size_t>", (void*)&fBitMap, "fBitMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInverseBitMap", (void*)&fInverseBitMap);
      R__insp.InspectMember("map<size_t,std::string>", (void*)&fInverseBitMap, "fInverseBitMap.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLChanSWStatus(void *p) {
      return  p ? new(p) ::RAT::DU::ChanSWStatus : new ::RAT::DU::ChanSWStatus;
   }
   static void *newArray_RATcLcLDUcLcLChanSWStatus(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::ChanSWStatus[nElements] : new ::RAT::DU::ChanSWStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLChanSWStatus(void *p) {
      delete ((::RAT::DU::ChanSWStatus*)p);
   }
   static void deleteArray_RATcLcLDUcLcLChanSWStatus(void *p) {
      delete [] ((::RAT::DU::ChanSWStatus*)p);
   }
   static void destruct_RATcLcLDUcLcLChanSWStatus(void *p) {
      typedef ::RAT::DU::ChanSWStatus current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLChanSWStatus(TBuffer &buf, void *obj) {
      ((::RAT::DU::ChanSWStatus*)obj)->::RAT::DU::ChanSWStatus::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::ChanSWStatus

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void TrigBits::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::TrigBits.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void TrigBits::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::TrigBits.
      TClass *R__cl = ::RAT::DU::TrigBits::IsA();
      if (R__cl || R__insp.IsA()) { }
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLTrigBits(void *p) {
      return  p ? new(p) ::RAT::DU::TrigBits : new ::RAT::DU::TrigBits;
   }
   static void *newArray_RATcLcLDUcLcLTrigBits(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::TrigBits[nElements] : new ::RAT::DU::TrigBits[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLTrigBits(void *p) {
      delete ((::RAT::DU::TrigBits*)p);
   }
   static void deleteArray_RATcLcLDUcLcLTrigBits(void *p) {
      delete [] ((::RAT::DU::TrigBits*)p);
   }
   static void destruct_RATcLcLDUcLcLTrigBits(void *p) {
      typedef ::RAT::DU::TrigBits current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLTrigBits(TBuffer &buf, void *obj) {
      ((::RAT::DU::TrigBits*)obj)->::RAT::DU::TrigBits::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::TrigBits

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void PMTInfo::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::PMTInfo.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void PMTInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::PMTInfo.
      TClass *R__cl = ::RAT::DU::PMTInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPositions", (void*)&fPositions);
      R__insp.InspectMember("vector<TVector3>", (void*)&fPositions, "fPositions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirections", (void*)&fDirections);
      R__insp.InspectMember("vector<TVector3>", (void*)&fDirections, "fDirections.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypes", (void*)&fTypes);
      R__insp.InspectMember("vector<EPMTType>", (void*)&fTypes, "fTypes.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPetalStatus", (void*)&fPetalStatus);
      R__insp.InspectMember("vector<EPetalStatus>", (void*)&fPetalStatus, "fPetalStatus.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPanels", (void*)&fPanels);
      R__insp.InspectMember("vector<int>", (void*)&fPanels, "fPanels.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLPMTInfo(void *p) {
      return  p ? new(p) ::RAT::DU::PMTInfo : new ::RAT::DU::PMTInfo;
   }
   static void *newArray_RATcLcLDUcLcLPMTInfo(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::PMTInfo[nElements] : new ::RAT::DU::PMTInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLPMTInfo(void *p) {
      delete ((::RAT::DU::PMTInfo*)p);
   }
   static void deleteArray_RATcLcLDUcLcLPMTInfo(void *p) {
      delete [] ((::RAT::DU::PMTInfo*)p);
   }
   static void destruct_RATcLcLDUcLcLPMTInfo(void *p) {
      typedef ::RAT::DU::PMTInfo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLPMTInfo(TBuffer &buf, void *obj) {
      ((::RAT::DU::PMTInfo*)obj)->::RAT::DU::PMTInfo::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::PMTInfo

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void PanelInfo::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::PanelInfo.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void PanelInfo::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::PanelInfo.
      TClass *R__cl = ::RAT::DU::PanelInfo::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPositions", (void*)&fPositions);
      R__insp.InspectMember("vector<TVector3>", (void*)&fPositions, "fPositions.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirections", (void*)&fDirections);
      R__insp.InspectMember("vector<TVector3>", (void*)&fDirections, "fDirections.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypes", (void*)&fTypes);
      R__insp.InspectMember("vector<EPanelType>", (void*)&fTypes, "fTypes.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPanels", (void*)&fPanels);
      R__insp.InspectMember("vector<int>", (void*)&fPanels, "fPanels.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLPanelInfo(void *p) {
      return  p ? new(p) ::RAT::DU::PanelInfo : new ::RAT::DU::PanelInfo;
   }
   static void *newArray_RATcLcLDUcLcLPanelInfo(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::PanelInfo[nElements] : new ::RAT::DU::PanelInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLPanelInfo(void *p) {
      delete ((::RAT::DU::PanelInfo*)p);
   }
   static void deleteArray_RATcLcLDUcLcLPanelInfo(void *p) {
      delete [] ((::RAT::DU::PanelInfo*)p);
   }
   static void destruct_RATcLcLDUcLcLPanelInfo(void *p) {
      typedef ::RAT::DU::PanelInfo current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLPanelInfo(TBuffer &buf, void *obj) {
      ((::RAT::DU::PanelInfo*)obj)->::RAT::DU::PanelInfo::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::PanelInfo

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void ChanHWStatus::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::ChanHWStatus.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void ChanHWStatus::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::ChanHWStatus.
      TClass *R__cl = ::RAT::DU::ChanHWStatus::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDQCH", (void*)&fDQCH);
      R__insp.InspectMember("vector<int>", (void*)&fDQCH, "fDQCH.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDQCR", (void*)&fDQCR);
      R__insp.InspectMember("vector<int>", (void*)&fDQCR, "fDQCR.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDQXX", (void*)&fDQXX);
      R__insp.InspectMember("vector<int>", (void*)&fDQXX, "fDQXX.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDQID", (void*)&fDQID);
      R__insp.InspectMember("vector<int>", (void*)&fDQID, "fDQID.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusN100", &fStatusN100);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusN20", &fStatusN20);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusELO", &fStatusELO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusEHI", &fStatusEHI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusON", &fStatusON);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusOELO", &fStatusOELO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatusOEHI", &fStatusOEHI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstantThreshold", &fConstantThreshold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSNO", &fSNO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseConstantThreshold", &fUseConstantThreshold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnabled", &fEnabled);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLChanHWStatus(void *p) {
      return  p ? new(p) ::RAT::DU::ChanHWStatus : new ::RAT::DU::ChanHWStatus;
   }
   static void *newArray_RATcLcLDUcLcLChanHWStatus(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::ChanHWStatus[nElements] : new ::RAT::DU::ChanHWStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLChanHWStatus(void *p) {
      delete ((::RAT::DU::ChanHWStatus*)p);
   }
   static void deleteArray_RATcLcLDUcLcLChanHWStatus(void *p) {
      delete [] ((::RAT::DU::ChanHWStatus*)p);
   }
   static void destruct_RATcLcLDUcLcLChanHWStatus(void *p) {
      typedef ::RAT::DU::ChanHWStatus current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLChanHWStatus(TBuffer &buf, void *obj) {
      ((::RAT::DU::ChanHWStatus*)obj)->::RAT::DU::ChanHWStatus::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::ChanHWStatus

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void Segmentor::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::Segmentor.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void Segmentor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::Segmentor.
      TClass *R__cl = ::RAT::DU::Segmentor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSegmentIDs", (void*)&fSegmentIDs);
      R__insp.InspectMember("vector<unsigned int>", (void*)&fSegmentIDs, "fSegmentIDs.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopulations", (void*)&fPopulations);
      R__insp.InspectMember("vector<unsigned int>", (void*)&fPopulations, "fPopulations.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDivisions", &fNDivisions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPatternZaxis", &fPatternZaxis);
      R__insp.InspectMember(fPatternZaxis, "fPatternZaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPatternXaxis", &fPatternXaxis);
      R__insp.InspectMember(fPatternXaxis, "fPatternXaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPatternYaxis", &fPatternYaxis);
      R__insp.InspectMember(fPatternYaxis, "fPatternYaxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPatternOrigin", &fPatternOrigin);
      R__insp.InspectMember(fPatternOrigin, "fPatternOrigin.");
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLSegmentor(void *p) {
      return  p ? new(p) ::RAT::DU::Segmentor : new ::RAT::DU::Segmentor;
   }
   static void *newArray_RATcLcLDUcLcLSegmentor(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::Segmentor[nElements] : new ::RAT::DU::Segmentor[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLSegmentor(void *p) {
      delete ((::RAT::DU::Segmentor*)p);
   }
   static void deleteArray_RATcLcLDUcLcLSegmentor(void *p) {
      delete [] ((::RAT::DU::Segmentor*)p);
   }
   static void destruct_RATcLcLDUcLcLSegmentor(void *p) {
      typedef ::RAT::DU::Segmentor current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLSegmentor(TBuffer &buf, void *obj) {
      ((::RAT::DU::Segmentor*)obj)->::RAT::DU::Segmentor::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::Segmentor

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void LightPathCalculator::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::LightPathCalculator.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void LightPathCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::LightPathCalculator.
      TClass *R__cl = ::RAT::DU::LightPathCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeckInnerRadius", &fNeckInnerRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeckOuterRadius", &fNeckOuterRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAVInnerRadius", &fAVInnerRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAVOuterRadius", &fAVOuterRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMTRadius", &fPMTRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillZ", &fFillZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLoopCeiling", &fLoopCeiling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFinalLoopSize", &fFinalLoopSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPathPrecision", &fPathPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerAVRIVal", &fInnerAVRIVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperTargetRIVal", &fUpperTargetRIVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerTargetRIVal", &fLowerTargetRIVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAVRIVal", &fAVRIVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaterRIVal", &fWaterRIVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIncidentVecOnPMT", &fIncidentVecOnPMT);
      R__insp.InspectMember(fIncidentVecOnPMT, "fIncidentVecOnPMT.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitialLightVec", &fInitialLightVec);
      R__insp.InspectMember(fInitialLightVec, "fInitialLightVec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartPos", &fStartPos);
      R__insp.InspectMember(fStartPos, "fStartPos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndPos", &fEndPos);
      R__insp.InspectMember(fEndPos, "fEndPos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightPathEndPos", &fLightPathEndPos);
      R__insp.InspectMember(fLightPathEndPos, "fLightPathEndPos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMTTargetTheta", &fPMTTargetTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTIR", &fIsTIR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResvHit", &fResvHit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXAVNeck", &fXAVNeck);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fELLIEEvent", &fELLIEEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStraightLine", &fStraightLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnAV1st", &fPointOnAV1st);
      R__insp.InspectMember(fPointOnAV1st, "fPointOnAV1st.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnAV2nd", &fPointOnAV2nd);
      R__insp.InspectMember(fPointOnAV2nd, "fPointOnAV2nd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnAV3rd", &fPointOnAV3rd);
      R__insp.InspectMember(fPointOnAV3rd, "fPointOnAV3rd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnAV4th", &fPointOnAV4th);
      R__insp.InspectMember(fPointOnAV4th, "fPointOnAV4th.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnNeck1st", &fPointOnNeck1st);
      R__insp.InspectMember(fPointOnNeck1st, "fPointOnNeck1st.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnNeck2nd", &fPointOnNeck2nd);
      R__insp.InspectMember(fPointOnNeck2nd, "fPointOnNeck2nd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnNeck3rd", &fPointOnNeck3rd);
      R__insp.InspectMember(fPointOnNeck3rd, "fPointOnNeck3rd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointOnNeck4th", &fPointOnNeck4th);
      R__insp.InspectMember(fPointOnNeck4th, "fPointOnNeck4th.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightPathType", &fLightPathType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightPathTypeMap", (void*)&fLightPathTypeMap);
      R__insp.InspectMember("map<eLightPathType,std::string>", (void*)&fLightPathTypeMap, "fLightPathTypeMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInInnerAV", &fDistInInnerAV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInUpperTarget", &fDistInUpperTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInLowerTarget", &fDistInLowerTarget);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInAV", &fDistInAV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInWater", &fDistInWater);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInNeckInnerAV", &fDistInNeckInnerAV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInNeckAV", &fDistInNeckAV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistInNeckWater", &fDistInNeckWater);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnergy", &fEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSolidAngle", &fSolidAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCosThetaAvg", &fCosThetaAvg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFresnelTCoeff", &fFresnelTCoeff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFresnelRCoeff", &fFresnelRCoeff);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLLightPathCalculator(void *p) {
      return  p ? new(p) ::RAT::DU::LightPathCalculator : new ::RAT::DU::LightPathCalculator;
   }
   static void *newArray_RATcLcLDUcLcLLightPathCalculator(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::LightPathCalculator[nElements] : new ::RAT::DU::LightPathCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLLightPathCalculator(void *p) {
      delete ((::RAT::DU::LightPathCalculator*)p);
   }
   static void deleteArray_RATcLcLDUcLcLLightPathCalculator(void *p) {
      delete [] ((::RAT::DU::LightPathCalculator*)p);
   }
   static void destruct_RATcLcLDUcLcLLightPathCalculator(void *p) {
      typedef ::RAT::DU::LightPathCalculator current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLLightPathCalculator(TBuffer &buf, void *obj) {
      ((::RAT::DU::LightPathCalculator*)obj)->::RAT::DU::LightPathCalculator::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::LightPathCalculator

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLShadowingCalculator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ShadowingCalculator : new ::RAT::DU::ShadowingCalculator;
   }
   static void *newArray_RATcLcLDUcLcLShadowingCalculator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ShadowingCalculator[nElements] : new ::RAT::DU::ShadowingCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLShadowingCalculator(void *p) {
      delete ((::RAT::DU::ShadowingCalculator*)p);
   }
   static void deleteArray_RATcLcLDUcLcLShadowingCalculator(void *p) {
      delete [] ((::RAT::DU::ShadowingCalculator*)p);
   }
   static void destruct_RATcLcLDUcLcLShadowingCalculator(void *p) {
      typedef ::RAT::DU::ShadowingCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DU::ShadowingCalculator

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void GroupVelocity::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::GroupVelocity.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void GroupVelocity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::GroupVelocity.
      TClass *R__cl = ::RAT::DU::GroupVelocity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerAVGroupVelocity", &fInnerAVGroupVelocity);
      R__insp.InspectMember(fInnerAVGroupVelocity, "fInnerAVGroupVelocity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAVGroupVelocity", &fAVGroupVelocity);
      R__insp.InspectMember(fAVGroupVelocity, "fAVGroupVelocity.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaterGroupVelocity", &fWaterGroupVelocity);
      R__insp.InspectMember(fWaterGroupVelocity, "fWaterGroupVelocity.");
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLGroupVelocity(void *p) {
      return  p ? new(p) ::RAT::DU::GroupVelocity : new ::RAT::DU::GroupVelocity;
   }
   static void *newArray_RATcLcLDUcLcLGroupVelocity(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::GroupVelocity[nElements] : new ::RAT::DU::GroupVelocity[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLGroupVelocity(void *p) {
      delete ((::RAT::DU::GroupVelocity*)p);
   }
   static void deleteArray_RATcLcLDUcLcLGroupVelocity(void *p) {
      delete [] ((::RAT::DU::GroupVelocity*)p);
   }
   static void destruct_RATcLcLDUcLcLGroupVelocity(void *p) {
      typedef ::RAT::DU::GroupVelocity current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLGroupVelocity(TBuffer &buf, void *obj) {
      ((::RAT::DU::GroupVelocity*)obj)->::RAT::DU::GroupVelocity::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::GroupVelocity

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void EffectiveVelocity::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::EffectiveVelocity.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void EffectiveVelocity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::EffectiveVelocity.
      TClass *R__cl = ::RAT::DU::EffectiveVelocity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInnerAVVelocity", &fInnerAVVelocity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAVVelocity", &fAVVelocity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWaterVelocity", &fWaterVelocity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLEffectiveVelocity(void *p) {
      return  p ? new(p) ::RAT::DU::EffectiveVelocity : new ::RAT::DU::EffectiveVelocity;
   }
   static void *newArray_RATcLcLDUcLcLEffectiveVelocity(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::EffectiveVelocity[nElements] : new ::RAT::DU::EffectiveVelocity[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLEffectiveVelocity(void *p) {
      delete ((::RAT::DU::EffectiveVelocity*)p);
   }
   static void deleteArray_RATcLcLDUcLcLEffectiveVelocity(void *p) {
      delete [] ((::RAT::DU::EffectiveVelocity*)p);
   }
   static void destruct_RATcLcLDUcLcLEffectiveVelocity(void *p) {
      typedef ::RAT::DU::EffectiveVelocity current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLEffectiveVelocity(TBuffer &buf, void *obj) {
      ((::RAT::DU::EffectiveVelocity*)obj)->::RAT::DU::EffectiveVelocity::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::EffectiveVelocity

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void PMTCalStatus::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::PMTCalStatus.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void PMTCalStatus::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::PMTCalStatus.
      TClass *R__cl = ::RAT::DU::PMTCalStatus::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdstMask", &fPdstMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTslpMask", &fTslpMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTWMask", &fTWMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fECAHitMask", &fECAHitMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPCAHitMask", &fPCAHitMask);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdstStatus", (void*)&fPdstStatus);
      R__insp.InspectMember("vector<int>", (void*)&fPdstStatus, "fPdstStatus.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTslpStatus", (void*)&fTslpStatus);
      R__insp.InspectMember("vector<int>", (void*)&fTslpStatus, "fTslpStatus.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTWStatus", (void*)&fTWStatus);
      R__insp.InspectMember("vector<int>", (void*)&fTWStatus, "fTWStatus.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdstBoardID", (void*)&fPdstBoardID);
      R__insp.InspectMember("vector<int>", (void*)&fPdstBoardID, "fPdstBoardID.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTslpBoardID", (void*)&fTslpBoardID);
      R__insp.InspectMember("vector<int>", (void*)&fTslpBoardID, "fTslpBoardID.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlag", (void*)&fFlag);
      R__insp.InspectMember("vector<int>", (void*)&fFlag, "fFlag.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flagHits", (void*)&flagHits);
      R__insp.InspectMember("vector<int>", (void*)&flagHits, "flagHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChannelFlags", (void*)&fChannelFlags);
      R__insp.InspectMember("vector<int>", (void*)&fChannelFlags, "fChannelFlags.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLPMTCalStatus(void *p) {
      return  p ? new(p) ::RAT::DU::PMTCalStatus : new ::RAT::DU::PMTCalStatus;
   }
   static void *newArray_RATcLcLDUcLcLPMTCalStatus(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::PMTCalStatus[nElements] : new ::RAT::DU::PMTCalStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLPMTCalStatus(void *p) {
      delete ((::RAT::DU::PMTCalStatus*)p);
   }
   static void deleteArray_RATcLcLDUcLcLPMTCalStatus(void *p) {
      delete [] ((::RAT::DU::PMTCalStatus*)p);
   }
   static void destruct_RATcLcLDUcLcLPMTCalStatus(void *p) {
      typedef ::RAT::DU::PMTCalStatus current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLPMTCalStatus(TBuffer &buf, void *obj) {
      ((::RAT::DU::PMTCalStatus*)obj)->::RAT::DU::PMTCalStatus::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::PMTCalStatus

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLReactorNuOsc(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReactorNuOsc : new ::RAT::DU::ReactorNuOsc;
   }
   static void *newArray_RATcLcLDUcLcLReactorNuOsc(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReactorNuOsc[nElements] : new ::RAT::DU::ReactorNuOsc[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLReactorNuOsc(void *p) {
      delete ((::RAT::DU::ReactorNuOsc*)p);
   }
   static void deleteArray_RATcLcLDUcLcLReactorNuOsc(void *p) {
      delete [] ((::RAT::DU::ReactorNuOsc*)p);
   }
   static void destruct_RATcLcLDUcLcLReactorNuOsc(void *p) {
      typedef ::RAT::DU::ReactorNuOsc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DU::ReactorNuOsc

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDUcLcLReconCorrector_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DU::ReconCorrector.
      typedef ::ROOTShadow::Shadow::RAT::DU::ReconCorrector ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ReconCorrector*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitDone", &sobj->fInitDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeVValuesOld1", (void*)&sobj->fMeVValuesOld1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fMeVValuesOld1, "fMeVValuesOld1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeVValuesNew1", (void*)&sobj->fMeVValuesNew1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fMeVValuesNew1, "fMeVValuesNew1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPredictedNphotonsOld1", (void*)&sobj->fPredictedNphotonsOld1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fPredictedNphotonsOld1, "fPredictedNphotonsOld1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPredictedNphotonsNew1", (void*)&sobj->fPredictedNphotonsNew1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fPredictedNphotonsNew1, "fPredictedNphotonsNew1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeVValuesOld2", (void*)&sobj->fMeVValuesOld2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fMeVValuesOld2, "fMeVValuesOld2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeVValuesNew2", (void*)&sobj->fMeVValuesNew2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fMeVValuesNew2, "fMeVValuesNew2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPredictedNphotonsOld2", (void*)&sobj->fPredictedNphotonsOld2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fPredictedNphotonsOld2, "fPredictedNphotonsOld2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPredictedNphotonsNew2", (void*)&sobj->fPredictedNphotonsNew2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fPredictedNphotonsNew2, "fPredictedNphotonsNew2.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLReconCorrector(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReconCorrector : new ::RAT::DU::ReconCorrector;
   }
   static void *newArray_RATcLcLDUcLcLReconCorrector(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReconCorrector[nElements] : new ::RAT::DU::ReconCorrector[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLReconCorrector(void *p) {
      delete ((::RAT::DU::ReconCorrector*)p);
   }
   static void deleteArray_RATcLcLDUcLcLReconCorrector(void *p) {
      delete [] ((::RAT::DU::ReconCorrector*)p);
   }
   static void destruct_RATcLcLDUcLcLReconCorrector(void *p) {
      typedef ::RAT::DU::ReconCorrector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DU::ReconCorrector

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void EnergySystematics::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::EnergySystematics.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RAT::DU::EnergySystematics::Class(),this);
   } else {
      R__b.WriteClassBuffer(RAT::DU::EnergySystematics::Class(),this);
   }
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void EnergySystematics::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::EnergySystematics.
      TClass *R__cl = ::RAT::DU::EnergySystematics::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "resolution_uncertainty", &resolution_uncertainty);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "energy_scale_systematic", &energy_scale_systematic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "reconstruction_smearing_factor", &reconstruction_smearing_factor);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLEnergySystematics(void *p) {
      delete ((::RAT::DU::EnergySystematics*)p);
   }
   static void deleteArray_RATcLcLDUcLcLEnergySystematics(void *p) {
      delete [] ((::RAT::DU::EnergySystematics*)p);
   }
   static void destruct_RATcLcLDUcLcLEnergySystematics(void *p) {
      typedef ::RAT::DU::EnergySystematics current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DU::EnergySystematics

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLDUcLcLReconCalibrator_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::DU::ReconCalibrator.
      typedef ::ROOTShadow::Shadow::RAT::DU::ReconCalibrator ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::DU::ReconCalibrator*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitDone", &sobj->fInitDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZoffsetAV", &sobj->fZoffsetAV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadiusAVOuterSqr", &sobj->fRadiusAVOuterSqr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsData1", (void*)&sobj->fCoefficientsData1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsData1, "fCoefficientsData1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsSim1", (void*)&sobj->fCoefficientsSim1);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsSim1, "fCoefficientsSim1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsData2", (void*)&sobj->fCoefficientsData2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsData2, "fCoefficientsData2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsSim2", (void*)&sobj->fCoefficientsSim2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsSim2, "fCoefficientsSim2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsExtData2", (void*)&sobj->fCoefficientsExtData2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsExtData2, "fCoefficientsExtData2.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCoefficientsExtSim2", (void*)&sobj->fCoefficientsExtSim2);
      R__insp.InspectMember("vector<double>", (void*)&sobj->fCoefficientsExtSim2, "fCoefficientsExtSim2.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLReconCalibrator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReconCalibrator : new ::RAT::DU::ReconCalibrator;
   }
   static void *newArray_RATcLcLDUcLcLReconCalibrator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::DU::ReconCalibrator[nElements] : new ::RAT::DU::ReconCalibrator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLReconCalibrator(void *p) {
      delete ((::RAT::DU::ReconCalibrator*)p);
   }
   static void deleteArray_RATcLcLDUcLcLReconCalibrator(void *p) {
      delete [] ((::RAT::DU::ReconCalibrator*)p);
   }
   static void destruct_RATcLcLDUcLcLReconCalibrator(void *p) {
      typedef ::RAT::DU::ReconCalibrator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DU::ReconCalibrator

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void Point3D::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::Point3D.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void Point3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::Point3D.
      TClass *R__cl = ::RAT::DU::Point3D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSystem", &fSystem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos[3]", fPos);
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLPoint3D(void *p) {
      return  p ? new(p) ::RAT::DU::Point3D : new ::RAT::DU::Point3D;
   }
   static void *newArray_RATcLcLDUcLcLPoint3D(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::Point3D[nElements] : new ::RAT::DU::Point3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLPoint3D(void *p) {
      delete ((::RAT::DU::Point3D*)p);
   }
   static void deleteArray_RATcLcLDUcLcLPoint3D(void *p) {
      delete [] ((::RAT::DU::Point3D*)p);
   }
   static void destruct_RATcLcLDUcLcLPoint3D(void *p) {
      typedef ::RAT::DU::Point3D current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLPoint3D(TBuffer &buf, void *obj) {
      ((::RAT::DU::Point3D*)obj)->::RAT::DU::Point3D::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::Point3D

      namespace RAT {
         namespace DU {
//______________________________________________________________________________
void TimeResidualCalculator::Streamer(TBuffer &R__b)
{
   // Stream an object of class RAT::DU::TimeResidualCalculator.

   TObject::Streamer(R__b);
}

} // namespace RAT::DU
} // namespace RAT::DU
//______________________________________________________________________________
      namespace RAT {
         namespace DU {
void TimeResidualCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RAT::DU::TimeResidualCalculator.
      TClass *R__cl = ::RAT::DU::TimeResidualCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPartialFlag", &fPartialFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLightPath", &fLightPath);
      R__insp.InspectMember(fLightPath, "fLightPath.");
      TObject::ShowMembers(R__insp);
}

} // namespace RAT::DU
} // namespace RAT::DU
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLDUcLcLTimeResidualCalculator(void *p) {
      return  p ? new(p) ::RAT::DU::TimeResidualCalculator : new ::RAT::DU::TimeResidualCalculator;
   }
   static void *newArray_RATcLcLDUcLcLTimeResidualCalculator(Long_t nElements, void *p) {
      return p ? new(p) ::RAT::DU::TimeResidualCalculator[nElements] : new ::RAT::DU::TimeResidualCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLDUcLcLTimeResidualCalculator(void *p) {
      delete ((::RAT::DU::TimeResidualCalculator*)p);
   }
   static void deleteArray_RATcLcLDUcLcLTimeResidualCalculator(void *p) {
      delete [] ((::RAT::DU::TimeResidualCalculator*)p);
   }
   static void destruct_RATcLcLDUcLcLTimeResidualCalculator(void *p) {
      typedef ::RAT::DU::TimeResidualCalculator current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RATcLcLDUcLcLTimeResidualCalculator(TBuffer &buf, void *obj) {
      ((::RAT::DU::TimeResidualCalculator*)obj)->::RAT::DU::TimeResidualCalculator::Streamer(buf);
   }
} // end of namespace ROOTDict for class ::RAT::DU::TimeResidualCalculator

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLPcLcLLightPath_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::LP::LightPath.
      typedef ::ROOTShadow::Shadow::RAT::LP::LightPath ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPath*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnergy", &sobj->fEnergy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoint", (void*)&sobj->fPoint);
      R__insp.InspectMember("vector<RAT::DU::Point3D>", (void*)&sobj->fPoint, "fPoint.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", (void*)&sobj->fDirection);
      R__insp.InspectMember("vector<TVector3>", (void*)&sobj->fDirection, "fDirection.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegionType", (void*)&sobj->fRegionType);
      R__insp.InspectMember("vector<RegionType>", (void*)&sobj->fRegionType, "fRegionType.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitter", (void*)&sobj->fFitter);
      R__insp.InspectMember("string", (void*)&sobj->fFitter, "fFitter.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLLPcLcLLightPath(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPath : new ::RAT::LP::LightPath;
   }
   static void *newArray_RATcLcLLPcLcLLightPath(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPath[nElements] : new ::RAT::LP::LightPath[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLLPcLcLLightPath(void *p) {
      delete ((::RAT::LP::LightPath*)p);
   }
   static void deleteArray_RATcLcLLPcLcLLightPath(void *p) {
      delete [] ((::RAT::LP::LightPath*)p);
   }
   static void destruct_RATcLcLLPcLcLLightPath(void *p) {
      typedef ::RAT::LP::LightPath current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::LP::LightPath

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLPcLcLLightPathFitter_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::LP::LightPathFitter.
      typedef ::ROOTShadow::Shadow::RAT::LP::LightPathFitter ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathFitter*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLLPcLcLLightPathFitter(void *p) {
      delete ((::RAT::LP::LightPathFitter*)p);
   }
   static void deleteArray_RATcLcLLPcLcLLightPathFitter(void *p) {
      delete [] ((::RAT::LP::LightPathFitter*)p);
   }
   static void destruct_RATcLcLLPcLcLLightPathFitter(void *p) {
      typedef ::RAT::LP::LightPathFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::LP::LightPathFitter

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightFitter_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::LP::LightPathStraightFitter.
      typedef ::ROOTShadow::Shadow::RAT::LP::LightPathStraightFitter ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightFitter*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.GenericShowMembers("RAT::LP::LightPathFitter", ( ::RAT::LP::LightPathFitter * )( (::RAT::LP::LightPathStraightFitter*) obj ), false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLLPcLcLLightPathStraightFitter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightFitter : new ::RAT::LP::LightPathStraightFitter;
   }
   static void *newArray_RATcLcLLPcLcLLightPathStraightFitter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightFitter[nElements] : new ::RAT::LP::LightPathStraightFitter[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLLPcLcLLightPathStraightFitter(void *p) {
      delete ((::RAT::LP::LightPathStraightFitter*)p);
   }
   static void deleteArray_RATcLcLLPcLcLLightPathStraightFitter(void *p) {
      delete [] ((::RAT::LP::LightPathStraightFitter*)p);
   }
   static void destruct_RATcLcLLPcLcLLightPathStraightFitter(void *p) {
      typedef ::RAT::LP::LightPathStraightFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::LP::LightPathStraightFitter

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightScint_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::LP::LightPathStraightScint.
      typedef ::ROOTShadow::Shadow::RAT::LP::LightPathStraightScint ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScint*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.GenericShowMembers("RAT::LP::LightPathFitter", ( ::RAT::LP::LightPathFitter * )( (::RAT::LP::LightPathStraightScint*) obj ), false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLLPcLcLLightPathStraightScint(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightScint : new ::RAT::LP::LightPathStraightScint;
   }
   static void *newArray_RATcLcLLPcLcLLightPathStraightScint(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightScint[nElements] : new ::RAT::LP::LightPathStraightScint[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLLPcLcLLightPathStraightScint(void *p) {
      delete ((::RAT::LP::LightPathStraightScint*)p);
   }
   static void deleteArray_RATcLcLLPcLcLLightPathStraightScint(void *p) {
      delete [] ((::RAT::LP::LightPathStraightScint*)p);
   }
   static void destruct_RATcLcLLPcLcLLightPathStraightScint(void *p) {
      typedef ::RAT::LP::LightPathStraightScint current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::LP::LightPathStraightScint

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLLPcLcLLightPathStraightScintWater_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::LP::LightPathStraightScintWater.
      typedef ::ROOTShadow::Shadow::RAT::LP::LightPathStraightScintWater ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::LP::LightPathStraightScintWater*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.GenericShowMembers("RAT::LP::LightPathFitter", ( ::RAT::LP::LightPathFitter * )( (::RAT::LP::LightPathStraightScintWater*) obj ), false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLLPcLcLLightPathStraightScintWater(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightScintWater : new ::RAT::LP::LightPathStraightScintWater;
   }
   static void *newArray_RATcLcLLPcLcLLightPathStraightScintWater(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::LP::LightPathStraightScintWater[nElements] : new ::RAT::LP::LightPathStraightScintWater[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLLPcLcLLightPathStraightScintWater(void *p) {
      delete ((::RAT::LP::LightPathStraightScintWater*)p);
   }
   static void deleteArray_RATcLcLLPcLcLLightPathStraightScintWater(void *p) {
      delete [] ((::RAT::LP::LightPathStraightScintWater*)p);
   }
   static void destruct_RATcLcLLPcLcLLightPathStraightScintWater(void *p) {
      typedef ::RAT::LP::LightPathStraightScintWater current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::LP::LightPathStraightScintWater

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLFitterPMT_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::FitterPMT.
      typedef ::ROOTShadow::Shadow::RAT::FitterPMT ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::FitterPMT*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &sobj->fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCCCC", &sobj->fCCCC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &sobj->fTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeError", &sobj->fTimeError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQHL", &sobj->fQHL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQHLError", &sobj->fQHLError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQHS", &sobj->fQHS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQHSError", &sobj->fQHSError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQLX", &sobj->fQLX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQLXError", &sobj->fQLXError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
      R__insp.InspectMember(sobj->fStatus, "fStatus.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCrossTalkFlag", &sobj->fCrossTalkFlag);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLFitterPMT(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::FitterPMT : new ::RAT::FitterPMT;
   }
   static void *newArray_RATcLcLFitterPMT(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::FitterPMT[nElements] : new ::RAT::FitterPMT[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLFitterPMT(void *p) {
      delete ((::RAT::FitterPMT*)p);
   }
   static void deleteArray_RATcLcLFitterPMT(void *p) {
      delete [] ((::RAT::FitterPMT*)p);
   }
   static void destruct_RATcLcLFitterPMT(void *p) {
      typedef ::RAT::FitterPMT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::FitterPMT

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_ratzdabcLcLzdabfile(void *p) {
      delete ((::ratzdab::zdabfile*)p);
   }
   static void deleteArray_ratzdabcLcLzdabfile(void *p) {
      delete [] ((::ratzdab::zdabfile*)p);
   }
   static void destruct_ratzdabcLcLzdabfile(void *p) {
      typedef ::ratzdab::zdabfile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ratzdab::zdabfile

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ratzdab::zdabfile::zdab_file_read_error : new ::ratzdab::zdabfile::zdab_file_read_error;
   }
   static void *newArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ratzdab::zdabfile::zdab_file_read_error[nElements] : new ::ratzdab::zdabfile::zdab_file_read_error[nElements];
   }
   // Wrapper around operator delete
   static void delete_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) {
      delete ((::ratzdab::zdabfile::zdab_file_read_error*)p);
   }
   static void deleteArray_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) {
      delete [] ((::ratzdab::zdabfile::zdab_file_read_error*)p);
   }
   static void destruct_ratzdabcLcLzdabfilecLcLzdab_file_read_error(void *p) {
      typedef ::ratzdab::zdabfile::zdab_file_read_error current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ratzdab::zdabfile::zdab_file_read_error

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ratzdabcLcLunknown_record_error(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ratzdab::unknown_record_error : new ::ratzdab::unknown_record_error;
   }
   static void *newArray_ratzdabcLcLunknown_record_error(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ratzdab::unknown_record_error[nElements] : new ::ratzdab::unknown_record_error[nElements];
   }
   // Wrapper around operator delete
   static void delete_ratzdabcLcLunknown_record_error(void *p) {
      delete ((::ratzdab::unknown_record_error*)p);
   }
   static void deleteArray_ratzdabcLcLunknown_record_error(void *p) {
      delete [] ((::ratzdab::unknown_record_error*)p);
   }
   static void destruct_ratzdabcLcLunknown_record_error(void *p) {
      typedef ::ratzdab::unknown_record_error current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ratzdab::unknown_record_error

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_exception(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::exception : new ::exception;
   }
   static void *newArray_exception(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::exception[nElements] : new ::exception[nElements];
   }
   // Wrapper around operator delete
   static void delete_exception(void *p) {
      delete ((::exception*)p);
   }
   static void deleteArray_exception(void *p) {
      delete [] ((::exception*)p);
   }
   static void destruct_exception(void *p) {
      typedef ::exception current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::exception

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_RATcLcLDScLcLDataNotFound(void *p) {
      delete ((::RAT::DS::DataNotFound*)p);
   }
   static void deleteArray_RATcLcLDScLcLDataNotFound(void *p) {
      delete [] ((::RAT::DS::DataNotFound*)p);
   }
   static void destruct_RATcLcLDScLcLDataNotFound(void *p) {
      typedef ::RAT::DS::DataNotFound current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::DS::DataNotFound

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_PZdabFile(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::PZdabFile : new ::PZdabFile;
   }
   static void *newArray_PZdabFile(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::PZdabFile[nElements] : new ::PZdabFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_PZdabFile(void *p) {
      delete ((::PZdabFile*)p);
   }
   static void deleteArray_PZdabFile(void *p) {
      delete [] ((::PZdabFile*)p);
   }
   static void destruct_PZdabFile(void *p) {
      typedef ::PZdabFile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::PZdabFile

//______________________________________________________________________________
namespace ROOTDict {
   void RATcLcLBitManip_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class RAT::BitManip.
      typedef ::ROOTShadow::Shadow::RAT::BitManip ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::RAT::BitManip*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RATcLcLBitManip(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::BitManip : new ::RAT::BitManip;
   }
   static void *newArray_RATcLcLBitManip(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RAT::BitManip[nElements] : new ::RAT::BitManip[nElements];
   }
   // Wrapper around operator delete
   static void delete_RATcLcLBitManip(void *p) {
      delete ((::RAT::BitManip*)p);
   }
   static void deleteArray_RATcLcLBitManip(void *p) {
      delete [] ((::RAT::BitManip*)p);
   }
   static void destruct_RATcLcLBitManip(void *p) {
      typedef ::RAT::BitManip current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RAT::BitManip

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<unsigned int,RAT::DS::BitMask>.
      typedef ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::BitMask>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", &sobj->first);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
      R__insp.InspectMember(sobj->second, "second.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::BitMask> : new pair<unsigned int,RAT::DS::BitMask>;
   }
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::BitMask>[nElements] : new pair<unsigned int,RAT::DS::BitMask>[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      delete ((pair<unsigned int,RAT::DS::BitMask>*)p);
   }
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      delete [] ((pair<unsigned int,RAT::DS::BitMask>*)p);
   }
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      typedef pair<unsigned int,RAT::DS::BitMask> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<unsigned int,RAT::DS::BitMask>

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >.
      typedef ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", &sobj->first);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
      R__insp.InspectMember(sobj->second, "second.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > : new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >;
   }
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[nElements] : new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      delete ((pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)p);
   }
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      delete [] ((pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)p);
   }
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      typedef pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >.
      typedef ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", &sobj->first);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
      R__insp.InspectMember(sobj->second, "second.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > : new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >;
   }
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[nElements] : new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      delete ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)p);
   }
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      delete [] ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)p);
   }
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      typedef pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >.
      typedef ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", &sobj->first);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
      R__insp.InspectMember(sobj->second, "second.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > : new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >;
   }
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[nElements] : new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      delete ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)p);
   }
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      delete [] ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)p);
   }
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      typedef pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<unsigned int,RAT::DS::SOCPMT>.
      typedef ::ROOTShadow::Shadow::pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<unsigned int,RAT::DS::SOCPMT>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", &sobj->first);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
      R__insp.InspectMember(sobj->second, "second.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::SOCPMT> : new pair<unsigned int,RAT::DS::SOCPMT>;
   }
   static void *newArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<unsigned int,RAT::DS::SOCPMT>[nElements] : new pair<unsigned int,RAT::DS::SOCPMT>[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      delete ((pair<unsigned int,RAT::DS::SOCPMT>*)p);
   }
   static void deleteArray_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      delete [] ((pair<unsigned int,RAT::DS::SOCPMT>*)p);
   }
   static void destruct_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      typedef pair<unsigned int,RAT::DS::SOCPMT> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<unsigned int,RAT::DS::SOCPMT>

//______________________________________________________________________________
namespace ROOTDict {
   void pairlEstringcOstringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class pair<string,string>.
      typedef ::ROOTShadow::Shadow::pairlEstringcOstringgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const pair<string,string>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "first", (void*)&sobj->first);
      R__insp.InspectMember("string", (void*)&sobj->first, "first.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "second", (void*)&sobj->second);
      R__insp.InspectMember("string", (void*)&sobj->second, "second.", false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_pairlEstringcOstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<string,string> : new pair<string,string>;
   }
   static void *newArray_pairlEstringcOstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<string,string>[nElements] : new pair<string,string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_pairlEstringcOstringgR(void *p) {
      delete ((pair<string,string>*)p);
   }
   static void deleteArray_pairlEstringcOstringgR(void *p) {
      delete [] ((pair<string,string>*)p);
   }
   static void destruct_pairlEstringcOstringgR(void *p) {
      typedef pair<string,string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class pair<string,string>

//______________________________________________________________________________
namespace ROOTDict {
   void simple_ptr_nocopylERATcLcLDBTablegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class simple_ptr_nocopy<RAT::DBTable>.
      typedef ::ROOTShadow::Shadow::simple_ptr_nocopylERATcLcLDBTablegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::simple_ptr_nocopy<RAT::DBTable>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_pointer", &sobj->m_pointer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*m_count", &sobj->m_count);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_simple_ptr_nocopylERATcLcLDBTablegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::simple_ptr_nocopy<RAT::DBTable> : new ::simple_ptr_nocopy<RAT::DBTable>;
   }
   static void *newArray_simple_ptr_nocopylERATcLcLDBTablegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::simple_ptr_nocopy<RAT::DBTable>[nElements] : new ::simple_ptr_nocopy<RAT::DBTable>[nElements];
   }
   // Wrapper around operator delete
   static void delete_simple_ptr_nocopylERATcLcLDBTablegR(void *p) {
      delete ((::simple_ptr_nocopy<RAT::DBTable>*)p);
   }
   static void deleteArray_simple_ptr_nocopylERATcLcLDBTablegR(void *p) {
      delete [] ((::simple_ptr_nocopy<RAT::DBTable>*)p);
   }
   static void destruct_simple_ptr_nocopylERATcLcLDBTablegR(void *p) {
      typedef ::simple_ptr_nocopy<RAT::DBTable> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::simple_ptr_nocopy<RAT::DBTable>

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_PmtEventRecord(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::PmtEventRecord : new ::PmtEventRecord;
   }
   static void *newArray_PmtEventRecord(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::PmtEventRecord[nElements] : new ::PmtEventRecord[nElements];
   }
   // Wrapper around operator delete
   static void delete_PmtEventRecord(void *p) {
      delete ((::PmtEventRecord*)p);
   }
   static void deleteArray_PmtEventRecord(void *p) {
      delete [] ((::PmtEventRecord*)p);
   }
   static void destruct_PmtEventRecord(void *p) {
      typedef ::PmtEventRecord current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::PmtEventRecord

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_RunRecord(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RunRecord : new ::RunRecord;
   }
   static void *newArray_RunRecord(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RunRecord[nElements] : new ::RunRecord[nElements];
   }
   // Wrapper around operator delete
   static void delete_RunRecord(void *p) {
      delete ((::RunRecord*)p);
   }
   static void deleteArray_RunRecord(void *p) {
      delete [] ((::RunRecord*)p);
   }
   static void destruct_RunRecord(void *p) {
      typedef ::RunRecord current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::RunRecord

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TriggerInfo(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TriggerInfo : new ::TriggerInfo;
   }
   static void *newArray_TriggerInfo(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TriggerInfo[nElements] : new ::TriggerInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TriggerInfo(void *p) {
      delete ((::TriggerInfo*)p);
   }
   static void deleteArray_TriggerInfo(void *p) {
      delete [] ((::TriggerInfo*)p);
   }
   static void destruct_TriggerInfo(void *p) {
      typedef ::TriggerInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TriggerInfo

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_EpedRecord(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EpedRecord : new ::EpedRecord;
   }
   static void *newArray_EpedRecord(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::EpedRecord[nElements] : new ::EpedRecord[nElements];
   }
   // Wrapper around operator delete
   static void delete_EpedRecord(void *p) {
      delete ((::EpedRecord*)p);
   }
   static void deleteArray_EpedRecord(void *p) {
      delete [] ((::EpedRecord*)p);
   }
   static void destruct_EpedRecord(void *p) {
      typedef ::EpedRecord current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::EpedRecord

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_ManipRopeStatus(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ManipRopeStatus : new ::ManipRopeStatus;
   }
   static void *newArray_ManipRopeStatus(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ManipRopeStatus[nElements] : new ::ManipRopeStatus[nElements];
   }
   // Wrapper around operator delete
   static void delete_ManipRopeStatus(void *p) {
      delete ((::ManipRopeStatus*)p);
   }
   static void deleteArray_ManipRopeStatus(void *p) {
      delete [] ((::ManipRopeStatus*)p);
   }
   static void destruct_ManipRopeStatus(void *p) {
      typedef ::ManipRopeStatus current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::ManipRopeStatus

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_MTCReadoutData(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MTCReadoutData : new ::MTCReadoutData;
   }
   static void *newArray_MTCReadoutData(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::MTCReadoutData[nElements] : new ::MTCReadoutData[nElements];
   }
   // Wrapper around operator delete
   static void delete_MTCReadoutData(void *p) {
      delete ((::MTCReadoutData*)p);
   }
   static void deleteArray_MTCReadoutData(void *p) {
      delete [] ((::MTCReadoutData*)p);
   }
   static void destruct_MTCReadoutData(void *p) {
      typedef ::MTCReadoutData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::MTCReadoutData

namespace ROOTDict {
   void dequelERATcLcLDBTableKeygR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void dequelERATcLcLDBTableKeygR_Dictionary();
   static void *new_dequelERATcLcLDBTableKeygR(void *p = 0);
   static void *newArray_dequelERATcLcLDBTableKeygR(Long_t size, void *p);
   static void delete_dequelERATcLcLDBTableKeygR(void *p);
   static void deleteArray_dequelERATcLcLDBTableKeygR(void *p);
   static void destruct_dequelERATcLcLDBTableKeygR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const deque<RAT::DBTableKey>*)
   {
      deque<RAT::DBTableKey> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(deque<RAT::DBTableKey>),0);
      static ::ROOT::TGenericClassInfo 
         instance("deque<RAT::DBTableKey>", -2, "/home/root/cint/cint/lib/prec_stl/deque", 42,
                  typeid(deque<RAT::DBTableKey>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &dequelERATcLcLDBTableKeygR_Dictionary, isa_proxy, 0,
                  sizeof(deque<RAT::DBTableKey>) );
      instance.SetNew(&new_dequelERATcLcLDBTableKeygR);
      instance.SetNewArray(&newArray_dequelERATcLcLDBTableKeygR);
      instance.SetDelete(&delete_dequelERATcLcLDBTableKeygR);
      instance.SetDeleteArray(&deleteArray_dequelERATcLcLDBTableKeygR);
      instance.SetDestructor(&destruct_dequelERATcLcLDBTableKeygR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< deque<RAT::DBTableKey> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const deque<RAT::DBTableKey>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void dequelERATcLcLDBTableKeygR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const deque<RAT::DBTableKey>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_dequelERATcLcLDBTableKeygR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<RAT::DBTableKey> : new deque<RAT::DBTableKey>;
   }
   static void *newArray_dequelERATcLcLDBTableKeygR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) deque<RAT::DBTableKey>[nElements] : new deque<RAT::DBTableKey>[nElements];
   }
   // Wrapper around operator delete
   static void delete_dequelERATcLcLDBTableKeygR(void *p) {
      delete ((deque<RAT::DBTableKey>*)p);
   }
   static void deleteArray_dequelERATcLcLDBTableKeygR(void *p) {
      delete [] ((deque<RAT::DBTableKey>*)p);
   }
   static void destruct_dequelERATcLcLDBTableKeygR(void *p) {
      typedef deque<RAT::DBTableKey> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class deque<RAT::DBTableKey>

namespace ROOTDict {
   void listlERATcLcLDBLinkmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void listlERATcLcLDBLinkmUgR_Dictionary();
   static void *new_listlERATcLcLDBLinkmUgR(void *p = 0);
   static void *newArray_listlERATcLcLDBLinkmUgR(Long_t size, void *p);
   static void delete_listlERATcLcLDBLinkmUgR(void *p);
   static void deleteArray_listlERATcLcLDBLinkmUgR(void *p);
   static void destruct_listlERATcLcLDBLinkmUgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const list<RAT::DBLink*>*)
   {
      list<RAT::DBLink*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<RAT::DBLink*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("list<RAT::DBLink*>", -2, "/home/root/cint/cint/lib/prec_stl/list", 44,
                  typeid(list<RAT::DBLink*>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &listlERATcLcLDBLinkmUgR_Dictionary, isa_proxy, 0,
                  sizeof(list<RAT::DBLink*>) );
      instance.SetNew(&new_listlERATcLcLDBLinkmUgR);
      instance.SetNewArray(&newArray_listlERATcLcLDBLinkmUgR);
      instance.SetDelete(&delete_listlERATcLcLDBLinkmUgR);
      instance.SetDeleteArray(&deleteArray_listlERATcLcLDBLinkmUgR);
      instance.SetDestructor(&destruct_listlERATcLcLDBLinkmUgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< list<RAT::DBLink*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<RAT::DBLink*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void listlERATcLcLDBLinkmUgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const list<RAT::DBLink*>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_listlERATcLcLDBLinkmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) list<RAT::DBLink*> : new list<RAT::DBLink*>;
   }
   static void *newArray_listlERATcLcLDBLinkmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) list<RAT::DBLink*>[nElements] : new list<RAT::DBLink*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlERATcLcLDBLinkmUgR(void *p) {
      delete ((list<RAT::DBLink*>*)p);
   }
   static void deleteArray_listlERATcLcLDBLinkmUgR(void *p) {
      delete [] ((list<RAT::DBLink*>*)p);
   }
   static void destruct_listlERATcLcLDBLinkmUgR(void *p) {
      typedef list<RAT::DBLink*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class list<RAT::DBLink*>

namespace ROOTDict {
   void maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary();
   static void *new_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p = 0);
   static void *newArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(Long_t size, void *p);
   static void delete_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p);
   static void deleteArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p);
   static void destruct_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >*)
   {
      map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >) );
      instance.SetNew(&new_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR);
      instance.SetNewArray(&newArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR);
      instance.SetDelete(&delete_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR);
      instance.SetDeleteArray(&deleteArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR);
      instance.SetDestructor(&destruct_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> > : new map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >;
   }
   static void *newArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >[nElements] : new map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) {
      delete ((map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >*)p);
   }
   static void deleteArray_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) {
      delete [] ((map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >*)p);
   }
   static void destruct_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgR(void *p) {
      typedef map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >

namespace ROOTDict {
   void maplEpairlEstringcOstringgRcOintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEpairlEstringcOstringgRcOintgR_Dictionary();
   static void *new_maplEpairlEstringcOstringgRcOintgR(void *p = 0);
   static void *newArray_maplEpairlEstringcOstringgRcOintgR(Long_t size, void *p);
   static void delete_maplEpairlEstringcOstringgRcOintgR(void *p);
   static void deleteArray_maplEpairlEstringcOstringgRcOintgR(void *p);
   static void destruct_maplEpairlEstringcOstringgRcOintgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<pair<string,string>,int>*)
   {
      map<pair<string,string>,int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<pair<string,string>,int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<pair<string,string>,int>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<pair<string,string>,int>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEpairlEstringcOstringgRcOintgR_Dictionary, isa_proxy, 0,
                  sizeof(map<pair<string,string>,int>) );
      instance.SetNew(&new_maplEpairlEstringcOstringgRcOintgR);
      instance.SetNewArray(&newArray_maplEpairlEstringcOstringgRcOintgR);
      instance.SetDelete(&delete_maplEpairlEstringcOstringgRcOintgR);
      instance.SetDeleteArray(&deleteArray_maplEpairlEstringcOstringgRcOintgR);
      instance.SetDestructor(&destruct_maplEpairlEstringcOstringgRcOintgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<pair<string,string>,int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<pair<string,string>,int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEpairlEstringcOstringgRcOintgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<pair<string,string>,int>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEpairlEstringcOstringgRcOintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<pair<string,string>,int> : new map<pair<string,string>,int>;
   }
   static void *newArray_maplEpairlEstringcOstringgRcOintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<pair<string,string>,int>[nElements] : new map<pair<string,string>,int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEpairlEstringcOstringgRcOintgR(void *p) {
      delete ((map<pair<string,string>,int>*)p);
   }
   static void deleteArray_maplEpairlEstringcOstringgRcOintgR(void *p) {
      delete [] ((map<pair<string,string>,int>*)p);
   }
   static void destruct_maplEpairlEstringcOstringgRcOintgR(void *p) {
      typedef map<pair<string,string>,int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<pair<string,string>,int>

namespace ROOTDict {
   void maplEstringcODouble32_tgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEstringcODouble32_tgR_Dictionary();
   static void *new_maplEstringcODouble32_tgR(void *p = 0);
   static void *newArray_maplEstringcODouble32_tgR(Long_t size, void *p);
   static void delete_maplEstringcODouble32_tgR(void *p);
   static void deleteArray_maplEstringcODouble32_tgR(void *p);
   static void destruct_maplEstringcODouble32_tgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<string,Double32_t>*)
   {
      map<string,Double32_t> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,Double32_t>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<string,Double32_t>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<string,Double32_t>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEstringcODouble32_tgR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,Double32_t>) );
      instance.SetNew(&new_maplEstringcODouble32_tgR);
      instance.SetNewArray(&newArray_maplEstringcODouble32_tgR);
      instance.SetDelete(&delete_maplEstringcODouble32_tgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcODouble32_tgR);
      instance.SetDestructor(&destruct_maplEstringcODouble32_tgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<string,Double32_t> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,Double32_t>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEstringcODouble32_tgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<string,Double32_t>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEstringcODouble32_tgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,Double32_t> : new map<string,Double32_t>;
   }
   static void *newArray_maplEstringcODouble32_tgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,Double32_t>[nElements] : new map<string,Double32_t>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcODouble32_tgR(void *p) {
      delete ((map<string,Double32_t>*)p);
   }
   static void deleteArray_maplEstringcODouble32_tgR(void *p) {
      delete [] ((map<string,Double32_t>*)p);
   }
   static void destruct_maplEstringcODouble32_tgR(void *p) {
      typedef map<string,Double32_t> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<string,Double32_t>

namespace ROOTDict {
   void maplEstringcORATcLcLDScLcLClassifierResultgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary();
   static void *new_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p = 0);
   static void *newArray_maplEstringcORATcLcLDScLcLClassifierResultgR(Long_t size, void *p);
   static void delete_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p);
   static void deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p);
   static void destruct_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<string,RAT::DS::ClassifierResult>*)
   {
      map<string,RAT::DS::ClassifierResult> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,RAT::DS::ClassifierResult>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<string,RAT::DS::ClassifierResult>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<string,RAT::DS::ClassifierResult>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,RAT::DS::ClassifierResult>) );
      instance.SetNew(&new_maplEstringcORATcLcLDScLcLClassifierResultgR);
      instance.SetNewArray(&newArray_maplEstringcORATcLcLDScLcLClassifierResultgR);
      instance.SetDelete(&delete_maplEstringcORATcLcLDScLcLClassifierResultgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR);
      instance.SetDestructor(&destruct_maplEstringcORATcLcLDScLcLClassifierResultgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<string,RAT::DS::ClassifierResult> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,RAT::DS::ClassifierResult>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEstringcORATcLcLDScLcLClassifierResultgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<string,RAT::DS::ClassifierResult>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,RAT::DS::ClassifierResult> : new map<string,RAT::DS::ClassifierResult>;
   }
   static void *newArray_maplEstringcORATcLcLDScLcLClassifierResultgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,RAT::DS::ClassifierResult>[nElements] : new map<string,RAT::DS::ClassifierResult>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) {
      delete ((map<string,RAT::DS::ClassifierResult>*)p);
   }
   static void deleteArray_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) {
      delete [] ((map<string,RAT::DS::ClassifierResult>*)p);
   }
   static void destruct_maplEstringcORATcLcLDScLcLClassifierResultgR(void *p) {
      typedef map<string,RAT::DS::ClassifierResult> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<string,RAT::DS::ClassifierResult>

namespace ROOTDict {
   void maplEstringcORATcLcLDScLcLFitResultgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEstringcORATcLcLDScLcLFitResultgR_Dictionary();
   static void *new_maplEstringcORATcLcLDScLcLFitResultgR(void *p = 0);
   static void *newArray_maplEstringcORATcLcLDScLcLFitResultgR(Long_t size, void *p);
   static void delete_maplEstringcORATcLcLDScLcLFitResultgR(void *p);
   static void deleteArray_maplEstringcORATcLcLDScLcLFitResultgR(void *p);
   static void destruct_maplEstringcORATcLcLDScLcLFitResultgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<string,RAT::DS::FitResult>*)
   {
      map<string,RAT::DS::FitResult> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,RAT::DS::FitResult>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<string,RAT::DS::FitResult>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<string,RAT::DS::FitResult>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEstringcORATcLcLDScLcLFitResultgR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,RAT::DS::FitResult>) );
      instance.SetNew(&new_maplEstringcORATcLcLDScLcLFitResultgR);
      instance.SetNewArray(&newArray_maplEstringcORATcLcLDScLcLFitResultgR);
      instance.SetDelete(&delete_maplEstringcORATcLcLDScLcLFitResultgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcORATcLcLDScLcLFitResultgR);
      instance.SetDestructor(&destruct_maplEstringcORATcLcLDScLcLFitResultgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<string,RAT::DS::FitResult> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,RAT::DS::FitResult>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEstringcORATcLcLDScLcLFitResultgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<string,RAT::DS::FitResult>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEstringcORATcLcLDScLcLFitResultgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,RAT::DS::FitResult> : new map<string,RAT::DS::FitResult>;
   }
   static void *newArray_maplEstringcORATcLcLDScLcLFitResultgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,RAT::DS::FitResult>[nElements] : new map<string,RAT::DS::FitResult>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcORATcLcLDScLcLFitResultgR(void *p) {
      delete ((map<string,RAT::DS::FitResult>*)p);
   }
   static void deleteArray_maplEstringcORATcLcLDScLcLFitResultgR(void *p) {
      delete [] ((map<string,RAT::DS::FitResult>*)p);
   }
   static void destruct_maplEstringcORATcLcLDScLcLFitResultgR(void *p) {
      typedef map<string,RAT::DS::FitResult> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<string,RAT::DS::FitResult>

namespace ROOTDict {
   void maplEstringcOstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEstringcOstringgR_Dictionary();
   static void *new_maplEstringcOstringgR(void *p = 0);
   static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
   static void delete_maplEstringcOstringgR(void *p);
   static void deleteArray_maplEstringcOstringgR(void *p);
   static void destruct_maplEstringcOstringgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
   {
      map<string,string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<string,string>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<string,string>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEstringcOstringgR_Dictionary, isa_proxy, 4,
                  sizeof(map<string,string>) );
      instance.SetNew(&new_maplEstringcOstringgR);
      instance.SetNewArray(&newArray_maplEstringcOstringgR);
      instance.SetDelete(&delete_maplEstringcOstringgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
      instance.SetDestructor(&destruct_maplEstringcOstringgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<string,string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEstringcOstringgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<string,string>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEstringcOstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,string> : new map<string,string>;
   }
   static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,string>[nElements] : new map<string,string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcOstringgR(void *p) {
      delete ((map<string,string>*)p);
   }
   static void deleteArray_maplEstringcOstringgR(void *p) {
      delete [] ((map<string,string>*)p);
   }
   static void destruct_maplEstringcOstringgR(void *p) {
      typedef map<string,string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<string,string>

namespace ROOTDict {
   void maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary();
   static void *new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p = 0);
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t size, void *p);
   static void delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,RAT::DS::BitMask>*)
   {
      map<unsigned int,RAT::DS::BitMask> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,RAT::DS::BitMask>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned int,RAT::DS::BitMask>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned int,RAT::DS::BitMask>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary, isa_proxy, 4,
                  sizeof(map<unsigned int,RAT::DS::BitMask>) );
      instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned int,RAT::DS::BitMask> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::BitMask>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPintcORATcLcLDScLcLBitMaskgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::BitMask>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::BitMask> : new map<unsigned int,RAT::DS::BitMask>;
   }
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::BitMask>[nElements] : new map<unsigned int,RAT::DS::BitMask>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      delete ((map<unsigned int,RAT::DS::BitMask>*)p);
   }
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      delete [] ((map<unsigned int,RAT::DS::BitMask>*)p);
   }
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLBitMaskgR(void *p) {
      typedef map<unsigned int,RAT::DS::BitMask> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned int,RAT::DS::BitMask>

namespace ROOTDict {
   void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary();
   static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p = 0);
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t size, void *p);
   static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)
   {
      map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >) );
      instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > : new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >;
   }
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[nElements] : new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      delete ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)p);
   }
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      delete [] ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)p);
   }
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void *p) {
      typedef map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >

namespace ROOTDict {
   void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary();
   static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p = 0);
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t size, void *p);
   static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)
   {
      map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >) );
      instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > : new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >;
   }
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[nElements] : new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      delete ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)p);
   }
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      delete [] ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)p);
   }
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void *p) {
      typedef map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >

namespace ROOTDict {
   void maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary();
   static void *new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p = 0);
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t size, void *p);
   static void delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)
   {
      map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >) );
      instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > : new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >;
   }
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[nElements] : new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      delete ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)p);
   }
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      delete [] ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)p);
   }
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void *p) {
      typedef map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >

namespace ROOTDict {
   void maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary();
   static void *new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p = 0);
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t size, void *p);
   static void delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,RAT::DS::SOCPMT>*)
   {
      map<unsigned int,RAT::DS::SOCPMT> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,RAT::DS::SOCPMT>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned int,RAT::DS::SOCPMT>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned int,RAT::DS::SOCPMT>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary, isa_proxy, 4,
                  sizeof(map<unsigned int,RAT::DS::SOCPMT>) );
      instance.SetNew(&new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetNewArray(&newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDelete(&delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.SetDestructor(&destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned int,RAT::DS::SOCPMT> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::SOCPMT>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned int,RAT::DS::SOCPMT>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::SOCPMT> : new map<unsigned int,RAT::DS::SOCPMT>;
   }
   static void *newArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,RAT::DS::SOCPMT>[nElements] : new map<unsigned int,RAT::DS::SOCPMT>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      delete ((map<unsigned int,RAT::DS::SOCPMT>*)p);
   }
   static void deleteArray_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      delete [] ((map<unsigned int,RAT::DS::SOCPMT>*)p);
   }
   static void destruct_maplEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void *p) {
      typedef map<unsigned int,RAT::DS::SOCPMT> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned int,RAT::DS::SOCPMT>

namespace ROOTDict {
   void maplEunsignedsPshortcOunsignedsPshortgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPshortcOunsignedsPshortgR_Dictionary();
   static void *new_maplEunsignedsPshortcOunsignedsPshortgR(void *p = 0);
   static void *newArray_maplEunsignedsPshortcOunsignedsPshortgR(Long_t size, void *p);
   static void delete_maplEunsignedsPshortcOunsignedsPshortgR(void *p);
   static void deleteArray_maplEunsignedsPshortcOunsignedsPshortgR(void *p);
   static void destruct_maplEunsignedsPshortcOunsignedsPshortgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned short,unsigned short>*)
   {
      map<unsigned short,unsigned short> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned short,unsigned short>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned short,unsigned short>", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned short,unsigned short>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPshortcOunsignedsPshortgR_Dictionary, isa_proxy, 0,
                  sizeof(map<unsigned short,unsigned short>) );
      instance.SetNew(&new_maplEunsignedsPshortcOunsignedsPshortgR);
      instance.SetNewArray(&newArray_maplEunsignedsPshortcOunsignedsPshortgR);
      instance.SetDelete(&delete_maplEunsignedsPshortcOunsignedsPshortgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOunsignedsPshortgR);
      instance.SetDestructor(&destruct_maplEunsignedsPshortcOunsignedsPshortgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned short,unsigned short> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned short,unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPshortcOunsignedsPshortgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned short,unsigned short>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPshortcOunsignedsPshortgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned short,unsigned short> : new map<unsigned short,unsigned short>;
   }
   static void *newArray_maplEunsignedsPshortcOunsignedsPshortgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned short,unsigned short>[nElements] : new map<unsigned short,unsigned short>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPshortcOunsignedsPshortgR(void *p) {
      delete ((map<unsigned short,unsigned short>*)p);
   }
   static void deleteArray_maplEunsignedsPshortcOunsignedsPshortgR(void *p) {
      delete [] ((map<unsigned short,unsigned short>*)p);
   }
   static void destruct_maplEunsignedsPshortcOunsignedsPshortgR(void *p) {
      typedef map<unsigned short,unsigned short> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned short,unsigned short>

namespace ROOTDict {
   void maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary();
   static void *new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p = 0);
   static void *newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(Long_t size, void *p);
   static void delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p);
   static void deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p);
   static void destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned short,vector<unsigned short> >*)
   {
      map<unsigned short,vector<unsigned short> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned short,vector<unsigned short> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<unsigned short,vector<unsigned short> >", -2, "/home/root/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<unsigned short,vector<unsigned short> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(map<unsigned short,vector<unsigned short> >) );
      instance.SetNew(&new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR);
      instance.SetNewArray(&newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR);
      instance.SetDelete(&delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR);
      instance.SetDeleteArray(&deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR);
      instance.SetDestructor(&destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<unsigned short,vector<unsigned short> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned short,vector<unsigned short> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<unsigned short,vector<unsigned short> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned short,vector<unsigned short> > : new map<unsigned short,vector<unsigned short> >;
   }
   static void *newArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned short,vector<unsigned short> >[nElements] : new map<unsigned short,vector<unsigned short> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) {
      delete ((map<unsigned short,vector<unsigned short> >*)p);
   }
   static void deleteArray_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) {
      delete [] ((map<unsigned short,vector<unsigned short> >*)p);
   }
   static void destruct_maplEunsignedsPshortcOvectorlEunsignedsPshortgRsPgR(void *p) {
      typedef map<unsigned short,vector<unsigned short> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<unsigned short,vector<unsigned short> >

namespace ROOTDict {
   void setlERATcLcLDBTableKeygR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void setlERATcLcLDBTableKeygR_Dictionary();
   static void *new_setlERATcLcLDBTableKeygR(void *p = 0);
   static void *newArray_setlERATcLcLDBTableKeygR(Long_t size, void *p);
   static void delete_setlERATcLcLDBTableKeygR(void *p);
   static void deleteArray_setlERATcLcLDBTableKeygR(void *p);
   static void destruct_setlERATcLcLDBTableKeygR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const set<RAT::DBTableKey>*)
   {
      set<RAT::DBTableKey> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<RAT::DBTableKey>),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<RAT::DBTableKey>", -2, "/home/root/cint/cint/lib/prec_stl/set", 49,
                  typeid(set<RAT::DBTableKey>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &setlERATcLcLDBTableKeygR_Dictionary, isa_proxy, 0,
                  sizeof(set<RAT::DBTableKey>) );
      instance.SetNew(&new_setlERATcLcLDBTableKeygR);
      instance.SetNewArray(&newArray_setlERATcLcLDBTableKeygR);
      instance.SetDelete(&delete_setlERATcLcLDBTableKeygR);
      instance.SetDeleteArray(&deleteArray_setlERATcLcLDBTableKeygR);
      instance.SetDestructor(&destruct_setlERATcLcLDBTableKeygR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Insert< set<RAT::DBTableKey> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<RAT::DBTableKey>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void setlERATcLcLDBTableKeygR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const set<RAT::DBTableKey>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_setlERATcLcLDBTableKeygR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<RAT::DBTableKey> : new set<RAT::DBTableKey>;
   }
   static void *newArray_setlERATcLcLDBTableKeygR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<RAT::DBTableKey>[nElements] : new set<RAT::DBTableKey>[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlERATcLcLDBTableKeygR(void *p) {
      delete ((set<RAT::DBTableKey>*)p);
   }
   static void deleteArray_setlERATcLcLDBTableKeygR(void *p) {
      delete [] ((set<RAT::DBTableKey>*)p);
   }
   static void destruct_setlERATcLcLDBTableKeygR(void *p) {
      typedef set<RAT::DBTableKey> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class set<RAT::DBTableKey>

namespace ROOTDict {
   void setlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void setlEstringgR_Dictionary();
   static void *new_setlEstringgR(void *p = 0);
   static void *newArray_setlEstringgR(Long_t size, void *p);
   static void delete_setlEstringgR(void *p);
   static void deleteArray_setlEstringgR(void *p);
   static void destruct_setlEstringgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const set<string>*)
   {
      set<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<string>", -2, "set.dll", 0,
                  typeid(set<string>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &setlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(set<string>) );
      instance.SetNew(&new_setlEstringgR);
      instance.SetNewArray(&newArray_setlEstringgR);
      instance.SetDelete(&delete_setlEstringgR);
      instance.SetDeleteArray(&deleteArray_setlEstringgR);
      instance.SetDestructor(&destruct_setlEstringgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Insert< set<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void setlEstringgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const set<string>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_setlEstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<string> : new set<string>;
   }
   static void *newArray_setlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<string>[nElements] : new set<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlEstringgR(void *p) {
      delete ((set<string>*)p);
   }
   static void deleteArray_setlEstringgR(void *p) {
      delete [] ((set<string>*)p);
   }
   static void destruct_setlEstringgR(void *p) {
      typedef set<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class set<string>

namespace ROOTDict {
   void vectorlERATcLcLDBTablemUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDBTablemUgR_Dictionary();
   static void *new_vectorlERATcLcLDBTablemUgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDBTablemUgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDBTablemUgR(void *p);
   static void deleteArray_vectorlERATcLcLDBTablemUgR(void *p);
   static void destruct_vectorlERATcLcLDBTablemUgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DBTable*>*)
   {
      vector<RAT::DBTable*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DBTable*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DBTable*>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DBTable*>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDBTablemUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DBTable*>) );
      instance.SetNew(&new_vectorlERATcLcLDBTablemUgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDBTablemUgR);
      instance.SetDelete(&delete_vectorlERATcLcLDBTablemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDBTablemUgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDBTablemUgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DBTable*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DBTable*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDBTablemUgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DBTable*>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDBTablemUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DBTable*> : new vector<RAT::DBTable*>;
   }
   static void *newArray_vectorlERATcLcLDBTablemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DBTable*>[nElements] : new vector<RAT::DBTable*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDBTablemUgR(void *p) {
      delete ((vector<RAT::DBTable*>*)p);
   }
   static void deleteArray_vectorlERATcLcLDBTablemUgR(void *p) {
      delete [] ((vector<RAT::DBTable*>*)p);
   }
   static void destruct_vectorlERATcLcLDBTablemUgR(void *p) {
      typedef vector<RAT::DBTable*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DBTable*>

namespace ROOTDict {
   void vectorlERATcLcLDBTablegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDBTablegR_Dictionary();
   static void *new_vectorlERATcLcLDBTablegR(void *p = 0);
   static void *newArray_vectorlERATcLcLDBTablegR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDBTablegR(void *p);
   static void deleteArray_vectorlERATcLcLDBTablegR(void *p);
   static void destruct_vectorlERATcLcLDBTablegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DBTable>*)
   {
      vector<RAT::DBTable> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DBTable>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DBTable>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DBTable>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDBTablegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DBTable>) );
      instance.SetNew(&new_vectorlERATcLcLDBTablegR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDBTablegR);
      instance.SetDelete(&delete_vectorlERATcLcLDBTablegR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDBTablegR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDBTablegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DBTable> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DBTable>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDBTablegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DBTable>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDBTablegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DBTable> : new vector<RAT::DBTable>;
   }
   static void *newArray_vectorlERATcLcLDBTablegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DBTable>[nElements] : new vector<RAT::DBTable>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDBTablegR(void *p) {
      delete ((vector<RAT::DBTable>*)p);
   }
   static void deleteArray_vectorlERATcLcLDBTablegR(void *p) {
      delete [] ((vector<RAT::DBTable>*)p);
   }
   static void destruct_vectorlERATcLcLDBTablegR(void *p) {
      typedef vector<RAT::DBTable> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DBTable>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLDigitisergR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLDigitisergR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLDigitisergR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLDigitisergR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLDigitisergR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLDigitisergR(void *p);
   static void destruct_vectorlERATcLcLDScLcLDigitisergR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::Digitiser>*)
   {
      vector<RAT::DS::Digitiser> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::Digitiser>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::Digitiser>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::Digitiser>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLDigitisergR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DS::Digitiser>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLDigitisergR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLDigitisergR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLDigitisergR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLDigitisergR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLDigitisergR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::Digitiser> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::Digitiser>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLDigitisergR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::Digitiser>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLDigitisergR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::Digitiser> : new vector<RAT::DS::Digitiser>;
   }
   static void *newArray_vectorlERATcLcLDScLcLDigitisergR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::Digitiser>[nElements] : new vector<RAT::DS::Digitiser>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLDigitisergR(void *p) {
      delete ((vector<RAT::DS::Digitiser>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLDigitisergR(void *p) {
      delete [] ((vector<RAT::DS::Digitiser>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLDigitisergR(void *p) {
      typedef vector<RAT::DS::Digitiser> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::Digitiser>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLECAHeadergR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLECAHeadergR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLECAHeadergR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLECAHeadergR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLECAHeadergR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLECAHeadergR(void *p);
   static void destruct_vectorlERATcLcLDScLcLECAHeadergR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::ECAHeader>*)
   {
      vector<RAT::DS::ECAHeader> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::ECAHeader>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::ECAHeader>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::ECAHeader>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLECAHeadergR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::ECAHeader>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLECAHeadergR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLECAHeadergR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLECAHeadergR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLECAHeadergR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLECAHeadergR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::ECAHeader> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::ECAHeader>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLECAHeadergR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::ECAHeader>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLECAHeadergR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::ECAHeader> : new vector<RAT::DS::ECAHeader>;
   }
   static void *newArray_vectorlERATcLcLDScLcLECAHeadergR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::ECAHeader>[nElements] : new vector<RAT::DS::ECAHeader>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLECAHeadergR(void *p) {
      delete ((vector<RAT::DS::ECAHeader>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLECAHeadergR(void *p) {
      delete [] ((vector<RAT::DS::ECAHeader>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLECAHeadergR(void *p) {
      typedef vector<RAT::DS::ECAHeader> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::ECAHeader>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLEVgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLEVgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLEVgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLEVgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLEVgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLEVgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLEVgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::EV>*)
   {
      vector<RAT::DS::EV> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::EV>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::EV>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::EV>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLEVgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::EV>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLEVgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLEVgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLEVgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLEVgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLEVgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::EV> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::EV>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLEVgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::EV>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLEVgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::EV> : new vector<RAT::DS::EV>;
   }
   static void *newArray_vectorlERATcLcLDScLcLEVgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::EV>[nElements] : new vector<RAT::DS::EV>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLEVgR(void *p) {
      delete ((vector<RAT::DS::EV>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLEVgR(void *p) {
      delete [] ((vector<RAT::DS::EV>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLEVgR(void *p) {
      typedef vector<RAT::DS::EV> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::EV>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLFitVertexgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLFitVertexgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLFitVertexgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLFitVertexgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLFitVertexgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLFitVertexgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLFitVertexgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::FitVertex>*)
   {
      vector<RAT::DS::FitVertex> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::FitVertex>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::FitVertex>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::FitVertex>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLFitVertexgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::FitVertex>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLFitVertexgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLFitVertexgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLFitVertexgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLFitVertexgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLFitVertexgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::FitVertex> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::FitVertex>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLFitVertexgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::FitVertex>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLFitVertexgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::FitVertex> : new vector<RAT::DS::FitVertex>;
   }
   static void *newArray_vectorlERATcLcLDScLcLFitVertexgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::FitVertex>[nElements] : new vector<RAT::DS::FitVertex>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLFitVertexgR(void *p) {
      delete ((vector<RAT::DS::FitVertex>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLFitVertexgR(void *p) {
      delete [] ((vector<RAT::DS::FitVertex>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLFitVertexgR(void *p) {
      typedef vector<RAT::DS::FitVertex> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::FitVertex>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLHeaderInfogR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLHeaderInfogR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLHeaderInfogR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLHeaderInfogR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLHeaderInfogR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLHeaderInfogR(void *p);
   static void destruct_vectorlERATcLcLDScLcLHeaderInfogR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::HeaderInfo>*)
   {
      vector<RAT::DS::HeaderInfo> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::HeaderInfo>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::HeaderInfo>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::HeaderInfo>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLHeaderInfogR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::HeaderInfo>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLHeaderInfogR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLHeaderInfogR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLHeaderInfogR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLHeaderInfogR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLHeaderInfogR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::HeaderInfo> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::HeaderInfo>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLHeaderInfogR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::HeaderInfo>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLHeaderInfogR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::HeaderInfo> : new vector<RAT::DS::HeaderInfo>;
   }
   static void *newArray_vectorlERATcLcLDScLcLHeaderInfogR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::HeaderInfo>[nElements] : new vector<RAT::DS::HeaderInfo>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLHeaderInfogR(void *p) {
      delete ((vector<RAT::DS::HeaderInfo>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLHeaderInfogR(void *p) {
      delete [] ((vector<RAT::DS::HeaderInfo>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLHeaderInfogR(void *p) {
      typedef vector<RAT::DS::HeaderInfo> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::HeaderInfo>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MC>*)
   {
      vector<RAT::DS::MC> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MC>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MC>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MC>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MC>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MC> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MC>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MC>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MC> : new vector<RAT::DS::MC>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MC>[nElements] : new vector<RAT::DS::MC>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCgR(void *p) {
      delete ((vector<RAT::DS::MC>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCgR(void *p) {
      delete [] ((vector<RAT::DS::MC>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCgR(void *p) {
      typedef vector<RAT::DS::MC> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MC>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCEVgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCEVgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCEVgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCEVgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCEVgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCEVgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCEVgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCEV>*)
   {
      vector<RAT::DS::MCEV> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCEV>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCEV>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCEV>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCEVgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCEV>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCEVgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCEVgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCEVgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCEVgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCEVgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCEV> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCEV>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCEVgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCEV>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCEVgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCEV> : new vector<RAT::DS::MCEV>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCEVgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCEV>[nElements] : new vector<RAT::DS::MCEV>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCEVgR(void *p) {
      delete ((vector<RAT::DS::MCEV>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCEVgR(void *p) {
      delete [] ((vector<RAT::DS::MCEV>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCEVgR(void *p) {
      typedef vector<RAT::DS::MCEV> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCEV>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCHitgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCHitgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCHitgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCHitgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCHitgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCHitgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCHitgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCHit>*)
   {
      vector<RAT::DS::MCHit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCHit>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCHit>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCHit>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCHitgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DS::MCHit>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCHitgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCHitgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCHitgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCHitgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCHitgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCHit> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCHit>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCHitgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCHit>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCHitgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCHit> : new vector<RAT::DS::MCHit>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCHitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCHit>[nElements] : new vector<RAT::DS::MCHit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCHitgR(void *p) {
      delete ((vector<RAT::DS::MCHit>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCHitgR(void *p) {
      delete [] ((vector<RAT::DS::MCHit>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCHitgR(void *p) {
      typedef vector<RAT::DS::MCHit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCHit>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCPEgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCPEgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCPEgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCPEgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCPEgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCPEgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCPEgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCPE>*)
   {
      vector<RAT::DS::MCPE> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCPE>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCPE>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCPE>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCPEgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCPE>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCPEgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPEgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPEgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPEgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPEgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCPE> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCPE>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCPEgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCPE>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCPEgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPE> : new vector<RAT::DS::MCPE>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCPEgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPE>[nElements] : new vector<RAT::DS::MCPE>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCPEgR(void *p) {
      delete ((vector<RAT::DS::MCPE>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCPEgR(void *p) {
      delete [] ((vector<RAT::DS::MCPE>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCPEgR(void *p) {
      typedef vector<RAT::DS::MCPE> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCPE>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCPMTgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCPMTgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCPMTgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCPMTgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCPMTgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCPMTgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCPMTgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCPMT>*)
   {
      vector<RAT::DS::MCPMT> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCPMT>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCPMT>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCPMT>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCPMTgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCPMT>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCPMTgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPMTgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPMTgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPMTgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPMTgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCPMT> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCPMT>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCPMTgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCPMT>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCPMTgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPMT> : new vector<RAT::DS::MCPMT>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCPMTgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPMT>[nElements] : new vector<RAT::DS::MCPMT>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCPMTgR(void *p) {
      delete ((vector<RAT::DS::MCPMT>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCPMTgR(void *p) {
      delete [] ((vector<RAT::DS::MCPMT>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCPMTgR(void *p) {
      typedef vector<RAT::DS::MCPMT> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCPMT>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCParticlegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCParticlegR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCParticlegR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCParticlegR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCParticlegR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCParticlegR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCParticlegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCParticle>*)
   {
      vector<RAT::DS::MCParticle> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCParticle>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCParticle>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCParticle>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCParticlegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCParticle>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCParticlegR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCParticlegR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCParticlegR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCParticlegR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCParticlegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCParticle> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCParticle>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCParticlegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCParticle>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCParticlegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCParticle> : new vector<RAT::DS::MCParticle>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCParticlegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCParticle>[nElements] : new vector<RAT::DS::MCParticle>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCParticlegR(void *p) {
      delete ((vector<RAT::DS::MCParticle>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCParticlegR(void *p) {
      delete [] ((vector<RAT::DS::MCParticle>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCParticlegR(void *p) {
      typedef vector<RAT::DS::MCParticle> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCParticle>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCPhotongR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCPhotongR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCPhotongR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCPhotongR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCPhotongR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCPhotongR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCPhotongR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCPhoton>*)
   {
      vector<RAT::DS::MCPhoton> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCPhoton>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCPhoton>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCPhoton>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCPhotongR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCPhoton>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCPhotongR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCPhotongR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCPhotongR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCPhotongR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCPhotongR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCPhoton> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCPhoton>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCPhotongR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCPhoton>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCPhotongR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPhoton> : new vector<RAT::DS::MCPhoton>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCPhotongR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCPhoton>[nElements] : new vector<RAT::DS::MCPhoton>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCPhotongR(void *p) {
      delete ((vector<RAT::DS::MCPhoton>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCPhotongR(void *p) {
      delete [] ((vector<RAT::DS::MCPhoton>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCPhotongR(void *p) {
      typedef vector<RAT::DS::MCPhoton> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCPhoton>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCTrackgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCTrackgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCTrackgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCTrackgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCTrackgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCTrackgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCTrackgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCTrack>*)
   {
      vector<RAT::DS::MCTrack> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCTrack>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCTrack>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCTrack>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCTrackgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCTrack>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCTrackgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCTrackgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCTrackgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCTrackgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCTrackgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCTrack> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCTrack>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCTrackgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCTrack>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCTrackgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCTrack> : new vector<RAT::DS::MCTrack>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCTrackgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCTrack>[nElements] : new vector<RAT::DS::MCTrack>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCTrackgR(void *p) {
      delete ((vector<RAT::DS::MCTrack>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCTrackgR(void *p) {
      delete [] ((vector<RAT::DS::MCTrack>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCTrackgR(void *p) {
      typedef vector<RAT::DS::MCTrack> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCTrack>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMCTrackStepgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMCTrackStepgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMCTrackStepgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMCTrackStepgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMCTrackStepgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MCTrackStep>*)
   {
      vector<RAT::DS::MCTrackStep> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MCTrackStep>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MCTrackStep>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MCTrackStep>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MCTrackStep>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMCTrackStepgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMCTrackStepgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMCTrackStepgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMCTrackStepgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MCTrackStep> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MCTrackStep>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMCTrackStepgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MCTrackStep>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCTrackStep> : new vector<RAT::DS::MCTrackStep>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMCTrackStepgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MCTrackStep>[nElements] : new vector<RAT::DS::MCTrackStep>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) {
      delete ((vector<RAT::DS::MCTrackStep>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) {
      delete [] ((vector<RAT::DS::MCTrackStep>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMCTrackStepgR(void *p) {
      typedef vector<RAT::DS::MCTrackStep> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MCTrackStep>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLMetaDBgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLMetaDBgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLMetaDBgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLMetaDBgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLMetaDBgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLMetaDBgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLMetaDBgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::MetaDB>*)
   {
      vector<RAT::DS::MetaDB> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::MetaDB>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::MetaDB>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::MetaDB>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLMetaDBgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::MetaDB>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLMetaDBgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLMetaDBgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLMetaDBgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLMetaDBgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLMetaDBgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::MetaDB> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::MetaDB>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLMetaDBgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::MetaDB>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLMetaDBgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MetaDB> : new vector<RAT::DS::MetaDB>;
   }
   static void *newArray_vectorlERATcLcLDScLcLMetaDBgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::MetaDB>[nElements] : new vector<RAT::DS::MetaDB>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLMetaDBgR(void *p) {
      delete ((vector<RAT::DS::MetaDB>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLMetaDBgR(void *p) {
      delete [] ((vector<RAT::DS::MetaDB>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLMetaDBgR(void *p) {
      typedef vector<RAT::DS::MetaDB> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::MetaDB>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::PMT<unsigned short> >*)
   {
      vector<RAT::DS::PMT<unsigned short> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::PMT<unsigned short> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::PMT<unsigned short> >", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::PMT<unsigned short> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DS::PMT<unsigned short> >) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::PMT<unsigned short> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::PMT<unsigned short> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::PMT<unsigned short> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::PMT<unsigned short> > : new vector<RAT::DS::PMT<unsigned short> >;
   }
   static void *newArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::PMT<unsigned short> >[nElements] : new vector<RAT::DS::PMT<unsigned short> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      delete ((vector<RAT::DS::PMT<unsigned short> >*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      delete [] ((vector<RAT::DS::PMT<unsigned short> >*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void *p) {
      typedef vector<RAT::DS::PMT<unsigned short> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::PMT<unsigned short> >

namespace ROOTDict {
   void vectorlERATcLcLDScLcLPMTCalgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLPMTCalgR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLPMTCalgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLPMTCalgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLPMTCalgR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLPMTCalgR(void *p);
   static void destruct_vectorlERATcLcLDScLcLPMTCalgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::PMTCal>*)
   {
      vector<RAT::DS::PMTCal> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::PMTCal>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::PMTCal>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::PMTCal>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLPMTCalgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::PMTCal>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLPMTCalgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLPMTCalgR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLPMTCalgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLPMTCalgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLPMTCalgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::PMTCal> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::PMTCal>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLPMTCalgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::PMTCal>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLPMTCalgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::PMTCal> : new vector<RAT::DS::PMTCal>;
   }
   static void *newArray_vectorlERATcLcLDScLcLPMTCalgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::PMTCal>[nElements] : new vector<RAT::DS::PMTCal>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLPMTCalgR(void *p) {
      delete ((vector<RAT::DS::PMTCal>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLPMTCalgR(void *p) {
      delete [] ((vector<RAT::DS::PMTCal>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLPMTCalgR(void *p) {
      typedef vector<RAT::DS::PMTCal> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::PMTCal>

namespace ROOTDict {
   void vectorlERATcLcLDScLcLTrigHeadergR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDScLcLTrigHeadergR_Dictionary();
   static void *new_vectorlERATcLcLDScLcLTrigHeadergR(void *p = 0);
   static void *newArray_vectorlERATcLcLDScLcLTrigHeadergR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDScLcLTrigHeadergR(void *p);
   static void deleteArray_vectorlERATcLcLDScLcLTrigHeadergR(void *p);
   static void destruct_vectorlERATcLcLDScLcLTrigHeadergR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DS::TrigHeader>*)
   {
      vector<RAT::DS::TrigHeader> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DS::TrigHeader>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DS::TrigHeader>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DS::TrigHeader>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDScLcLTrigHeadergR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RAT::DS::TrigHeader>) );
      instance.SetNew(&new_vectorlERATcLcLDScLcLTrigHeadergR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDScLcLTrigHeadergR);
      instance.SetDelete(&delete_vectorlERATcLcLDScLcLTrigHeadergR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDScLcLTrigHeadergR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDScLcLTrigHeadergR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DS::TrigHeader> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DS::TrigHeader>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDScLcLTrigHeadergR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DS::TrigHeader>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDScLcLTrigHeadergR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::TrigHeader> : new vector<RAT::DS::TrigHeader>;
   }
   static void *newArray_vectorlERATcLcLDScLcLTrigHeadergR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DS::TrigHeader>[nElements] : new vector<RAT::DS::TrigHeader>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDScLcLTrigHeadergR(void *p) {
      delete ((vector<RAT::DS::TrigHeader>*)p);
   }
   static void deleteArray_vectorlERATcLcLDScLcLTrigHeadergR(void *p) {
      delete [] ((vector<RAT::DS::TrigHeader>*)p);
   }
   static void destruct_vectorlERATcLcLDScLcLTrigHeadergR(void *p) {
      typedef vector<RAT::DS::TrigHeader> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DS::TrigHeader>

namespace ROOTDict {
   void vectorlERATcLcLDUcLcLPoint3DgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLDUcLcLPoint3DgR_Dictionary();
   static void *new_vectorlERATcLcLDUcLcLPoint3DgR(void *p = 0);
   static void *newArray_vectorlERATcLcLDUcLcLPoint3DgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLDUcLcLPoint3DgR(void *p);
   static void deleteArray_vectorlERATcLcLDUcLcLPoint3DgR(void *p);
   static void destruct_vectorlERATcLcLDUcLcLPoint3DgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::DU::Point3D>*)
   {
      vector<RAT::DU::Point3D> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::DU::Point3D>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::DU::Point3D>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::DU::Point3D>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLDUcLcLPoint3DgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::DU::Point3D>) );
      instance.SetNew(&new_vectorlERATcLcLDUcLcLPoint3DgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLDUcLcLPoint3DgR);
      instance.SetDelete(&delete_vectorlERATcLcLDUcLcLPoint3DgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLDUcLcLPoint3DgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLDUcLcLPoint3DgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::DU::Point3D> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::DU::Point3D>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLDUcLcLPoint3DgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::DU::Point3D>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLDUcLcLPoint3DgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DU::Point3D> : new vector<RAT::DU::Point3D>;
   }
   static void *newArray_vectorlERATcLcLDUcLcLPoint3DgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::DU::Point3D>[nElements] : new vector<RAT::DU::Point3D>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLDUcLcLPoint3DgR(void *p) {
      delete ((vector<RAT::DU::Point3D>*)p);
   }
   static void deleteArray_vectorlERATcLcLDUcLcLPoint3DgR(void *p) {
      delete [] ((vector<RAT::DU::Point3D>*)p);
   }
   static void destruct_vectorlERATcLcLDUcLcLPoint3DgR(void *p) {
      typedef vector<RAT::DU::Point3D> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::DU::Point3D>

namespace ROOTDict {
   void vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary();
   static void *new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p = 0);
   static void *newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(Long_t size, void *p);
   static void delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p);
   static void deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p);
   static void destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::LP::LightPath::RegionType>*)
   {
      vector<RAT::LP::LightPath::RegionType> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::LP::LightPath::RegionType>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::LP::LightPath::RegionType>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::LP::LightPath::RegionType>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::LP::LightPath::RegionType>) );
      instance.SetNew(&new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR);
      instance.SetNewArray(&newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR);
      instance.SetDelete(&delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR);
      instance.SetDestructor(&destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::LP::LightPath::RegionType> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::LP::LightPath::RegionType>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::LP::LightPath::RegionType>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::LP::LightPath::RegionType> : new vector<RAT::LP::LightPath::RegionType>;
   }
   static void *newArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::LP::LightPath::RegionType>[nElements] : new vector<RAT::LP::LightPath::RegionType>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) {
      delete ((vector<RAT::LP::LightPath::RegionType>*)p);
   }
   static void deleteArray_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) {
      delete [] ((vector<RAT::LP::LightPath::RegionType>*)p);
   }
   static void destruct_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypegR(void *p) {
      typedef vector<RAT::LP::LightPath::RegionType> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::LP::LightPath::RegionType>

namespace ROOTDict {
   void vectorlERATcLcLTrackNodemUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLTrackNodemUgR_Dictionary();
   static void *new_vectorlERATcLcLTrackNodemUgR(void *p = 0);
   static void *newArray_vectorlERATcLcLTrackNodemUgR(Long_t size, void *p);
   static void delete_vectorlERATcLcLTrackNodemUgR(void *p);
   static void deleteArray_vectorlERATcLcLTrackNodemUgR(void *p);
   static void destruct_vectorlERATcLcLTrackNodemUgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::TrackNode*>*)
   {
      vector<RAT::TrackNode*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::TrackNode*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::TrackNode*>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::TrackNode*>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLTrackNodemUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::TrackNode*>) );
      instance.SetNew(&new_vectorlERATcLcLTrackNodemUgR);
      instance.SetNewArray(&newArray_vectorlERATcLcLTrackNodemUgR);
      instance.SetDelete(&delete_vectorlERATcLcLTrackNodemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLTrackNodemUgR);
      instance.SetDestructor(&destruct_vectorlERATcLcLTrackNodemUgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::TrackNode*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::TrackNode*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLTrackNodemUgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::TrackNode*>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLTrackNodemUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::TrackNode*> : new vector<RAT::TrackNode*>;
   }
   static void *newArray_vectorlERATcLcLTrackNodemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::TrackNode*>[nElements] : new vector<RAT::TrackNode*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLTrackNodemUgR(void *p) {
      delete ((vector<RAT::TrackNode*>*)p);
   }
   static void deleteArray_vectorlERATcLcLTrackNodemUgR(void *p) {
      delete [] ((vector<RAT::TrackNode*>*)p);
   }
   static void destruct_vectorlERATcLcLTrackNodemUgR(void *p) {
      typedef vector<RAT::TrackNode*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::TrackNode*>

namespace ROOTDict {
   void vectorlERATcLcLTrackNodegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERATcLcLTrackNodegR_Dictionary();
   static void *new_vectorlERATcLcLTrackNodegR(void *p = 0);
   static void *newArray_vectorlERATcLcLTrackNodegR(Long_t size, void *p);
   static void delete_vectorlERATcLcLTrackNodegR(void *p);
   static void deleteArray_vectorlERATcLcLTrackNodegR(void *p);
   static void destruct_vectorlERATcLcLTrackNodegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<RAT::TrackNode>*)
   {
      vector<RAT::TrackNode> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RAT::TrackNode>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RAT::TrackNode>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<RAT::TrackNode>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlERATcLcLTrackNodegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RAT::TrackNode>) );
      instance.SetNew(&new_vectorlERATcLcLTrackNodegR);
      instance.SetNewArray(&newArray_vectorlERATcLcLTrackNodegR);
      instance.SetDelete(&delete_vectorlERATcLcLTrackNodegR);
      instance.SetDeleteArray(&deleteArray_vectorlERATcLcLTrackNodegR);
      instance.SetDestructor(&destruct_vectorlERATcLcLTrackNodegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<RAT::TrackNode> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RAT::TrackNode>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlERATcLcLTrackNodegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<RAT::TrackNode>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlERATcLcLTrackNodegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::TrackNode> : new vector<RAT::TrackNode>;
   }
   static void *newArray_vectorlERATcLcLTrackNodegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RAT::TrackNode>[nElements] : new vector<RAT::TrackNode>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERATcLcLTrackNodegR(void *p) {
      delete ((vector<RAT::TrackNode>*)p);
   }
   static void deleteArray_vectorlERATcLcLTrackNodegR(void *p) {
      delete [] ((vector<RAT::TrackNode>*)p);
   }
   static void destruct_vectorlERATcLcLTrackNodegR(void *p) {
      typedef vector<RAT::TrackNode> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<RAT::TrackNode>

namespace ROOTDict {
   void vectorlETVector3gR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETVector3gR_Dictionary();
   static void *new_vectorlETVector3gR(void *p = 0);
   static void *newArray_vectorlETVector3gR(Long_t size, void *p);
   static void delete_vectorlETVector3gR(void *p);
   static void deleteArray_vectorlETVector3gR(void *p);
   static void destruct_vectorlETVector3gR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<TVector3>*)
   {
      vector<TVector3> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TVector3>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TVector3>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<TVector3>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlETVector3gR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TVector3>) );
      instance.SetNew(&new_vectorlETVector3gR);
      instance.SetNewArray(&newArray_vectorlETVector3gR);
      instance.SetDelete(&delete_vectorlETVector3gR);
      instance.SetDeleteArray(&deleteArray_vectorlETVector3gR);
      instance.SetDestructor(&destruct_vectorlETVector3gR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<TVector3> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TVector3>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETVector3gR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<TVector3>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlETVector3gR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TVector3> : new vector<TVector3>;
   }
   static void *newArray_vectorlETVector3gR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TVector3>[nElements] : new vector<TVector3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETVector3gR(void *p) {
      delete ((vector<TVector3>*)p);
   }
   static void deleteArray_vectorlETVector3gR(void *p) {
      delete [] ((vector<TVector3>*)p);
   }
   static void destruct_vectorlETVector3gR(void *p) {
      typedef vector<TVector3> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<TVector3>

namespace ROOTDict {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector.dll", 0,
                  typeid(vector<double>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEdoublegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<double>

namespace ROOTDict {
   void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEfloatgR_Dictionary();
   static void *new_vectorlEfloatgR(void *p = 0);
   static void *newArray_vectorlEfloatgR(Long_t size, void *p);
   static void delete_vectorlEfloatgR(void *p);
   static void deleteArray_vectorlEfloatgR(void *p);
   static void destruct_vectorlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<float>*)
   {
      vector<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<float>", -2, "vector.dll", 0,
                  typeid(vector<float>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<float>) );
      instance.SetNew(&new_vectorlEfloatgR);
      instance.SetNewArray(&newArray_vectorlEfloatgR);
      instance.SetDelete(&delete_vectorlEfloatgR);
      instance.SetDeleteArray(&deleteArray_vectorlEfloatgR);
      instance.SetDestructor(&destruct_vectorlEfloatgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<float> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEfloatgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<float>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float> : new vector<float>;
   }
   static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEfloatgR(void *p) {
      delete ((vector<float>*)p);
   }
   static void deleteArray_vectorlEfloatgR(void *p) {
      delete [] ((vector<float>*)p);
   }
   static void destruct_vectorlEfloatgR(void *p) {
      typedef vector<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<float>

namespace ROOTDict {
   void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintgR_Dictionary();
   static void *new_vectorlEintgR(void *p = 0);
   static void *newArray_vectorlEintgR(Long_t size, void *p);
   static void delete_vectorlEintgR(void *p);
   static void deleteArray_vectorlEintgR(void *p);
   static void destruct_vectorlEintgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
   {
      vector<int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<int>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<int>) );
      instance.SetNew(&new_vectorlEintgR);
      instance.SetNewArray(&newArray_vectorlEintgR);
      instance.SetDelete(&delete_vectorlEintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEintgR);
      instance.SetDestructor(&destruct_vectorlEintgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEintgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<int>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete ((vector<int>*)p);
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] ((vector<int>*)p);
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<int>

namespace ROOTDict {
   void vectorlEpairlEstringcOstringgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEpairlEstringcOstringgRsPgR_Dictionary();
   static void *new_vectorlEpairlEstringcOstringgRsPgR(void *p = 0);
   static void *newArray_vectorlEpairlEstringcOstringgRsPgR(Long_t size, void *p);
   static void delete_vectorlEpairlEstringcOstringgRsPgR(void *p);
   static void deleteArray_vectorlEpairlEstringcOstringgRsPgR(void *p);
   static void destruct_vectorlEpairlEstringcOstringgRsPgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<pair<string,string> >*)
   {
      vector<pair<string,string> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<pair<string,string> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<pair<string,string> >", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<pair<string,string> >), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEpairlEstringcOstringgRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<pair<string,string> >) );
      instance.SetNew(&new_vectorlEpairlEstringcOstringgRsPgR);
      instance.SetNewArray(&newArray_vectorlEpairlEstringcOstringgRsPgR);
      instance.SetDelete(&delete_vectorlEpairlEstringcOstringgRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlEpairlEstringcOstringgRsPgR);
      instance.SetDestructor(&destruct_vectorlEpairlEstringcOstringgRsPgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<pair<string,string> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<pair<string,string> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEpairlEstringcOstringgRsPgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<pair<string,string> >*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEpairlEstringcOstringgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<string,string> > : new vector<pair<string,string> >;
   }
   static void *newArray_vectorlEpairlEstringcOstringgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<pair<string,string> >[nElements] : new vector<pair<string,string> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEpairlEstringcOstringgRsPgR(void *p) {
      delete ((vector<pair<string,string> >*)p);
   }
   static void deleteArray_vectorlEpairlEstringcOstringgRsPgR(void *p) {
      delete [] ((vector<pair<string,string> >*)p);
   }
   static void destruct_vectorlEpairlEstringcOstringgRsPgR(void *p) {
      typedef vector<pair<string,string> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<pair<string,string> >

namespace ROOTDict {
   void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEstringgR_Dictionary();
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "/home/root/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<string>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEstringgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<string>

namespace ROOTDict {
   void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPintgR_Dictionary();
   static void *new_vectorlEunsignedsPintgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPintgR(void *p);
   static void deleteArray_vectorlEunsignedsPintgR(void *p);
   static void destruct_vectorlEunsignedsPintgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned int>*)
   {
      vector<unsigned int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned int>", -2, "vector.dll", 0,
                  typeid(vector<unsigned int>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned int>) );
      instance.SetNew(&new_vectorlEunsignedsPintgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
      instance.SetDelete(&delete_vectorlEunsignedsPintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<unsigned int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEunsignedsPintgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<unsigned int>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int> : new vector<unsigned int>;
   }
   static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int>[nElements] : new vector<unsigned int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPintgR(void *p) {
      delete ((vector<unsigned int>*)p);
   }
   static void deleteArray_vectorlEunsignedsPintgR(void *p) {
      delete [] ((vector<unsigned int>*)p);
   }
   static void destruct_vectorlEunsignedsPintgR(void *p) {
      typedef vector<unsigned int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<unsigned int>

namespace ROOTDict {
   void vectorlEULong64_tgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEULong64_tgR_Dictionary();
   static void *new_vectorlEULong64_tgR(void *p = 0);
   static void *newArray_vectorlEULong64_tgR(Long_t size, void *p);
   static void delete_vectorlEULong64_tgR(void *p);
   static void deleteArray_vectorlEULong64_tgR(void *p);
   static void destruct_vectorlEULong64_tgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<ULong64_t>*)
   {
      vector<ULong64_t> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ULong64_t>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<ULong64_t>", -2, "vector.dll", 0,
                  typeid(vector<ULong64_t>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEULong64_tgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<ULong64_t>) );
      instance.SetNew(&new_vectorlEULong64_tgR);
      instance.SetNewArray(&newArray_vectorlEULong64_tgR);
      instance.SetDelete(&delete_vectorlEULong64_tgR);
      instance.SetDeleteArray(&deleteArray_vectorlEULong64_tgR);
      instance.SetDestructor(&destruct_vectorlEULong64_tgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<ULong64_t> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<ULong64_t>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEULong64_tgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<ULong64_t>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEULong64_tgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ULong64_t> : new vector<ULong64_t>;
   }
   static void *newArray_vectorlEULong64_tgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ULong64_t>[nElements] : new vector<ULong64_t>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEULong64_tgR(void *p) {
      delete ((vector<ULong64_t>*)p);
   }
   static void deleteArray_vectorlEULong64_tgR(void *p) {
      delete [] ((vector<ULong64_t>*)p);
   }
   static void destruct_vectorlEULong64_tgR(void *p) {
      typedef vector<ULong64_t> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<ULong64_t>

namespace ROOTDict {
   void vectorlEunsignedsPshortgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPshortgR_Dictionary();
   static void *new_vectorlEunsignedsPshortgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPshortgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPshortgR(void *p);
   static void deleteArray_vectorlEunsignedsPshortgR(void *p);
   static void destruct_vectorlEunsignedsPshortgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned short>*)
   {
      vector<unsigned short> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned short>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned short>", -2, "vector.dll", 0,
                  typeid(vector<unsigned short>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPshortgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned short>) );
      instance.SetNew(&new_vectorlEunsignedsPshortgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPshortgR);
      instance.SetDelete(&delete_vectorlEunsignedsPshortgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPshortgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPshortgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<unsigned short> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEunsignedsPshortgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<unsigned short>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPshortgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned short> : new vector<unsigned short>;
   }
   static void *newArray_vectorlEunsignedsPshortgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned short>[nElements] : new vector<unsigned short>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPshortgR(void *p) {
      delete ((vector<unsigned short>*)p);
   }
   static void deleteArray_vectorlEunsignedsPshortgR(void *p) {
      delete [] ((vector<unsigned short>*)p);
   }
   static void destruct_vectorlEunsignedsPshortgR(void *p) {
      typedef vector<unsigned short> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<unsigned short>

/********************************************************
* build/linuxx8664gcc/RAT_Dict.cc
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableRAT_Dict();

extern "C" void G__set_cpp_environmentRAT_Dict() {
  G__cpp_reset_tagtableRAT_Dict();
}
#include <new>
extern "C" int G__cpp_dllrevRAT_Dict() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* RAT */
static int G__RAT_Dict_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::to_ratdb_float_string((double) G__double(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::to_ratdb_double_string((double) G__double(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::escape_ratdb_string(*(string*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVector2* pobj;
         TVector2 xobj = RAT::TransformCoord(
*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, *(TVector3*) libp->para[2].ref, *(TVector2*) libp->para[3].ref
, *(TVector2*) libp->para[4].ref, *(TVector2*) libp->para[5].ref
, *(TVector3*) libp->para[6].ref);
         pobj = new TVector2(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::SphereToIcosahedron(*(TVector3*) libp->para[0].ref, *(TVector2*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) RAT::GetDataCleaningWord(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) RAT::GetDataCleaningWord(*(vector<std::string>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) RAT::EventIsClean(*(RAT::DS::EV*) libp->para[0].ref, (const ULong64_t) G__ULonglong(libp->para[1])
, (const Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) RAT::EventIsClean(*(RAT::DS::EV*) libp->para[0].ref, (const ULong64_t) G__ULonglong(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::CheckMask(*(RAT::DS::BitMask*) libp->para[0].ref, (const ULong64_t) G__ULonglong(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::MissingBits(*(RAT::DS::BitMask*) libp->para[0].ref, (const ULong64_t) G__ULonglong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         TVector3* pobj;
         TVector3 xobj = RAT::SunDirection((const int) G__int(libp->para[0]), (const int) G__int(libp->para[1])
, (const int) G__int(libp->para[2]), (const double) G__double(libp->para[3]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         TVector3* pobj;
         TVector3 xobj = RAT::SunDirection((const int) G__int(libp->para[0]), (const int) G__int(libp->para[1])
, (const int) G__int(libp->para[2]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::GetRATVersion();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::GetRATRevision();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::QuadraticRoots((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *(double*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         G4ThreeVector* pobj;
         G4ThreeVector xobj = RAT::SphericallyUniform3Vector();
         pobj = new G4ThreeVector(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::BitMask */
static int G__RAT_Dict_170_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::BitMask* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::BitMask[n];
     } else {
       p = new((void*) gvp) RAT::DS::BitMask[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::BitMask;
     } else {
       p = new((void*) gvp) RAT::DS::BitMask;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::BitMask* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DS::BitMask((const ULong64_t) G__ULonglong(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::DS::BitMask((const ULong64_t) G__ULonglong(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RAT::DS::BitMask*) G__getstructoffset())->Set((size_t) G__int(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::BitMask*) G__getstructoffset())->Set((size_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::BitMask*) G__getstructoffset())->Get((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((const RAT::DS::BitMask*) G__getstructoffset())->GetBits((const size_t) G__int(libp->para[0]), (const size_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((const RAT::DS::BitMask*) G__getstructoffset())->GetULong64_t((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::BitMask*) G__getstructoffset())->ToString();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::BitMask*) G__getstructoffset())->operator~();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask* pobj;
         const RAT::DS::BitMask xobj = ((const RAT::DS::BitMask*) G__getstructoffset())->operator&(*(RAT::DS::BitMask*) libp->para[0].ref);
         pobj = new RAT::DS::BitMask(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::BitMask*) G__getstructoffset())->operator&=(*(RAT::DS::BitMask*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask* pobj;
         const RAT::DS::BitMask xobj = ((const RAT::DS::BitMask*) G__getstructoffset())->operator|(*(RAT::DS::BitMask*) libp->para[0].ref);
         pobj = new RAT::DS::BitMask(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::BitMask*) G__getstructoffset())->operator|=(*(RAT::DS::BitMask*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask* pobj;
         const RAT::DS::BitMask xobj = ((const RAT::DS::BitMask*) G__getstructoffset())->operator^(*(RAT::DS::BitMask*) libp->para[0].ref);
         pobj = new RAT::DS::BitMask(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::BitMask*) G__getstructoffset())->operator^=(*(RAT::DS::BitMask*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::BitMask*) G__getstructoffset())->operator==(*(RAT::DS::BitMask*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::BitMask*) G__getstructoffset())->operator!=(*(RAT::DS::BitMask*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::BitMask*) G__getstructoffset())->operator Bool_t());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::BitMask::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::BitMask::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::BitMask::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::BitMask::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::BitMask*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::BitMask::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::BitMask::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::BitMask::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_170_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::BitMask::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_170_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::BitMask* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::BitMask(*(RAT::DS::BitMask*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::BitMask G__TRATcLcLDScLcLBitMask;
static int G__RAT_Dict_170_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::BitMask*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::BitMask*) (soff+(sizeof(RAT::DS::BitMask)*i)))->~G__TRATcLcLDScLcLBitMask();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::BitMask*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::BitMask*) (soff))->~G__TRATcLcLDScLcLBitMask();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_170_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::BitMask* dest = (RAT::DS::BitMask*) G__getstructoffset();
   *dest = *(RAT::DS::BitMask*) libp->para[0].ref;
   const RAT::DS::BitMask& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::Calib */
static int G__RAT_Dict_224_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Calib* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Calib[n];
     } else {
       p = new((void*) gvp) RAT::DS::Calib[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Calib;
     } else {
       p = new((void*) gvp) RAT::DS::Calib;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const RAT::DS::Calib*) G__getstructoffset())->GetSourceName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetSourceName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::Calib*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetID((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::Calib*) G__getstructoffset())->GetMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::Calib*) G__getstructoffset())->GetIntensity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetIntensity((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::Calib*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetTime((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3& obj = ((const RAT::DS::Calib*) G__getstructoffset())->GetPos();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetPos(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3& obj = ((const RAT::DS::Calib*) G__getstructoffset())->GetDir();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->SetDir(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::Calib::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Calib::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::Calib::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::Calib::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Calib*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Calib::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Calib::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Calib::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_224_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Calib::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_224_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::Calib* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::Calib(*(RAT::DS::Calib*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::Calib G__TRATcLcLDScLcLCalib;
static int G__RAT_Dict_224_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::Calib*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::Calib*) (soff+(sizeof(RAT::DS::Calib)*i)))->~G__TRATcLcLDScLcLCalib();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::Calib*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::Calib*) (soff))->~G__TRATcLcLDScLcLCalib();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_224_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Calib* dest = (RAT::DS::Calib*) G__getstructoffset();
   *dest = *(RAT::DS::Calib*) libp->para[0].ref;
   const RAT::DS::Calib& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::DataNotFound */
static int G__RAT_Dict_238_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::DataNotFound* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::DataNotFound(
*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))
, *((const string*) G__int(libp->para[2])));
     } else {
       p = new((void*) gvp) RAT::DS::DataNotFound(
*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))
, *((const string*) G__int(libp->para[2])));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::DataNotFound(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) RAT::DS::DataNotFound(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_238_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::DataNotFound* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::DataNotFound(*(RAT::DS::DataNotFound*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::DataNotFound G__TRATcLcLDScLcLDataNotFound;
static int G__RAT_Dict_238_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::DataNotFound*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::DataNotFound*) (soff+(sizeof(RAT::DS::DataNotFound)*i)))->~G__TRATcLcLDScLcLDataNotFound();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::DataNotFound*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::DataNotFound*) (soff))->~G__TRATcLcLDScLcLDataNotFound();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_238_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::DataNotFound* dest = (RAT::DS::DataNotFound*) G__getstructoffset();
   *dest = *(RAT::DS::DataNotFound*) libp->para[0].ref;
   const RAT::DS::DataNotFound& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::ClassifierResult */
static int G__RAT_Dict_474_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::ClassifierResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::ClassifierResult[n];
     } else {
       p = new((void*) gvp) RAT::DS::ClassifierResult[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::ClassifierResult;
     } else {
       p = new((void*) gvp) RAT::DS::ClassifierResult;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->SetClassification(*(string*) libp->para[0].ref, (const Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetClassification(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetClassificationNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->SetValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->SetExecutionTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetExecutionTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->SetFOM(*(string*) libp->para[0].ref, (const Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetFOM(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::ClassifierResult*) G__getstructoffset())->GetFOMNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::ClassifierResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ClassifierResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::ClassifierResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::ClassifierResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ClassifierResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ClassifierResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::ClassifierResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ClassifierResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_474_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::ClassifierResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_474_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::ClassifierResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::ClassifierResult(*(RAT::DS::ClassifierResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::ClassifierResult G__TRATcLcLDScLcLClassifierResult;
static int G__RAT_Dict_474_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::ClassifierResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::ClassifierResult*) (soff+(sizeof(RAT::DS::ClassifierResult)*i)))->~G__TRATcLcLDScLcLClassifierResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::ClassifierResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::ClassifierResult*) (soff))->~G__TRATcLcLDScLcLClassifierResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_474_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::ClassifierResult* dest = (RAT::DS::ClassifierResult*) G__getstructoffset();
   *dest = *(RAT::DS::ClassifierResult*) libp->para[0].ref;
   const RAT::DS::ClassifierResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::DataQCFlags */
static int G__RAT_Dict_488_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::DataQCFlags* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::DataQCFlags[n];
     } else {
       p = new((void*) gvp) RAT::DS::DataQCFlags[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::DataQCFlags;
     } else {
       p = new((void*) gvp) RAT::DS::DataQCFlags;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::DataQCFlags*) G__getstructoffset())->ExistFlags((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RAT::DS::DataQCFlags*) G__getstructoffset())->GetLatestPass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::DataQCFlags*) G__getstructoffset())->GetLatestPass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::DataQCFlags*) G__getstructoffset())->GetFlags((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((const RAT::DS::DataQCFlags*) G__getstructoffset())->GetFlags((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::DataQCFlags*) G__getstructoffset())->GetApplied((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((const RAT::DS::DataQCFlags*) G__getstructoffset())->GetApplied((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::DataQCFlags*) G__getstructoffset())->Set((const UInt_t) G__int(libp->para[0]), (const size_t) G__int(libp->para[1])
, (const bool) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::DataQCFlags*) G__getstructoffset())->SetFlags((const UInt_t) G__int(libp->para[0]), *(RAT::DS::BitMask*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::DataQCFlags*) G__getstructoffset())->SetApplied((const UInt_t) G__int(libp->para[0]), *(RAT::DS::BitMask*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::DataQCFlags::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::DataQCFlags::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::DataQCFlags::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::DataQCFlags::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::DataQCFlags*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::DataQCFlags::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::DataQCFlags::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::DataQCFlags::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_488_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::DataQCFlags::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_488_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::DataQCFlags* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::DataQCFlags(*(RAT::DS::DataQCFlags*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::DataQCFlags G__TRATcLcLDScLcLDataQCFlags;
static int G__RAT_Dict_488_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::DataQCFlags*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::DataQCFlags*) (soff+(sizeof(RAT::DS::DataQCFlags)*i)))->~G__TRATcLcLDScLcLDataQCFlags();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::DataQCFlags*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::DataQCFlags*) (soff))->~G__TRATcLcLDScLcLDataQCFlags();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_488_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::DataQCFlags* dest = (RAT::DS::DataQCFlags*) G__getstructoffset();
   *dest = *(RAT::DS::DataQCFlags*) libp->para[0].ref;
   const RAT::DS::DataQCFlags& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > */
static int G__RAT_Dict_493_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >[n];
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >;
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >(*(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >& obj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->operator=(*(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->begin();
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->end();
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->rbegin();
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->rend();
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->operator[](*(unsigned int*) G__UIntref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator,bool>* pobj;
         pair<map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator,bool> xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->insert(*(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])), *(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::value_type*) libp->para[1].ref);
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->erase(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->swap(*(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->find(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->count(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->lower_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_493_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator* pobj;
         map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator xobj = ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) G__getstructoffset())->upper_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > G__TmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR;
static int G__RAT_Dict_493_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) (soff+(sizeof(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >)*i)))->~G__TmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*) (soff))->~G__TmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<unsigned int,RAT::DS::BitMask> */
static int G__RAT_Dict_494_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::BitMask>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::BitMask>[n];
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::BitMask>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::BitMask>;
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::BitMask>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_494_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::BitMask>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<unsigned int,RAT::DS::BitMask>(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::BitMask*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<unsigned int,RAT::DS::BitMask>(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::BitMask*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_494_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<unsigned int,RAT::DS::BitMask>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<unsigned int,RAT::DS::BitMask>(*(pair<unsigned int,RAT::DS::BitMask>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<unsigned int,RAT::DS::BitMask> G__TpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR;
static int G__RAT_Dict_494_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<unsigned int,RAT::DS::BitMask>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<unsigned int,RAT::DS::BitMask>*) (soff+(sizeof(pair<unsigned int,RAT::DS::BitMask>)*i)))->~G__TpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<unsigned int,RAT::DS::BitMask>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<unsigned int,RAT::DS::BitMask>*) (soff))->~G__TpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::Digitiser */
static int G__RAT_Dict_498_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Digitiser* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Digitiser[n];
     } else {
       p = new((void*) gvp) RAT::DS::Digitiser[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Digitiser;
     } else {
       p = new((void*) gvp) RAT::DS::Digitiser;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetEventID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetEventID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetTrigTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetTrigTime((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetNWords());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetNWords((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetBoardID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetBoardID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetBit24());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetBit24((const UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetDataFormat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetDataFormat((const UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->GetIOPins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetIOPins((const UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->ExistsWaveform((const UShort_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<UShort_t>* pobj;
         const vector<UShort_t> xobj = ((const RAT::DS::Digitiser*) G__getstructoffset())->GetWaveform((const UShort_t) G__int(libp->para[0]));
         pobj = new vector<UShort_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->SetWaveform((const UShort_t) G__int(libp->para[0]), *(vector<UShort_t>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<UShort_t,std::vector<UShort_t> >* pobj;
         const map<UShort_t,std::vector<UShort_t> > xobj = ((const RAT::DS::Digitiser*) G__getstructoffset())->GetAllWaveforms();
         pobj = new map<UShort_t,std::vector<UShort_t> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->PruneWaveforms();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::Digitiser*) G__getstructoffset())->Average((const UShort_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::Digitiser*) G__getstructoffset())->Integral((const UShort_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->Min((const UShort_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::Digitiser*) G__getstructoffset())->Max((const UShort_t) G__int(libp->para[0]), (size_t) G__int(libp->para[1])
, (size_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<UShort_t>* pobj;
         const vector<UShort_t> xobj = ((const RAT::DS::Digitiser*) G__getstructoffset())->GetIDs();
         pobj = new vector<UShort_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::Digitiser::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Digitiser::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::Digitiser::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::Digitiser::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Digitiser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Digitiser::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Digitiser::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Digitiser::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_498_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Digitiser::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_498_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::Digitiser* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::Digitiser(*(RAT::DS::Digitiser*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::Digitiser G__TRATcLcLDScLcLDigitiser;
static int G__RAT_Dict_498_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::Digitiser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::Digitiser*) (soff+(sizeof(RAT::DS::Digitiser)*i)))->~G__TRATcLcLDScLcLDigitiser();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::Digitiser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::Digitiser*) (soff))->~G__TRATcLcLDScLcLDigitiser();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_498_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Digitiser* dest = (RAT::DS::Digitiser*) G__getstructoffset();
   *dest = *(RAT::DS::Digitiser*) libp->para[0].ref;
   const RAT::DS::Digitiser& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::ECAHeader */
static int G__RAT_Dict_508_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::ECAHeader* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::ECAHeader[n];
     } else {
       p = new((void*) gvp) RAT::DS::ECAHeader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::ECAHeader;
     } else {
       p = new((void*) gvp) RAT::DS::ECAHeader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetGTDelayCoarse());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetGTDelayCoarse((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetGTDelayFine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetGTDelayFine((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetChargePedestalAmplitude());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetChargePedestalAmplitude((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetChargePedestalWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetChargePedestalWidth((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetPatternID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetPatternID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetCalType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetCalType((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetNTSlopePoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetNTSlopePoints((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::ECAHeader*) G__getstructoffset())->GetFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->SetFlag((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::ECAHeader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ECAHeader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::ECAHeader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::ECAHeader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::ECAHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ECAHeader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::ECAHeader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::ECAHeader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_508_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::ECAHeader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_508_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::ECAHeader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::ECAHeader(*(RAT::DS::ECAHeader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::ECAHeader G__TRATcLcLDScLcLECAHeader;
static int G__RAT_Dict_508_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::ECAHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::ECAHeader*) (soff+(sizeof(RAT::DS::ECAHeader)*i)))->~G__TRATcLcLDScLcLECAHeader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::ECAHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::ECAHeader*) (soff))->~G__TRATcLcLDScLcLECAHeader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_508_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::ECAHeader* dest = (RAT::DS::ECAHeader*) G__getstructoffset();
   *dest = *(RAT::DS::ECAHeader*) libp->para[0].ref;
   const RAT::DS::ECAHeader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::UniversalTime */
static int G__RAT_Dict_509_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::UniversalTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::UniversalTime[n];
     } else {
       p = new((void*) gvp) RAT::DS::UniversalTime[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::UniversalTime;
     } else {
       p = new((void*) gvp) RAT::DS::UniversalTime;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::UniversalTime* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DS::UniversalTime(
(const UInt_t) G__int(libp->para[0]), (const UInt_t) G__int(libp->para[1])
, (const UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) RAT::DS::UniversalTime(
(const UInt_t) G__int(libp->para[0]), (const UInt_t) G__int(libp->para[1])
, (const UInt_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->GetDays());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->GetSeconds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::UniversalTime*) G__getstructoffset())->GetNanoSeconds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const tm* pobj;
         const tm xobj = ((const RAT::DS::UniversalTime*) G__getstructoffset())->GetTime((const Bool_t) G__int(libp->para[0]));
         pobj = new tm(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const tm* pobj;
         const tm xobj = ((const RAT::DS::UniversalTime*) G__getstructoffset())->GetTime();
         pobj = new tm(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime& obj = ((RAT::DS::UniversalTime*) G__getstructoffset())->operator+=(*(RAT::DS::UniversalTime*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime* pobj;
         const RAT::DS::UniversalTime xobj = ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator+(*(RAT::DS::UniversalTime*) libp->para[0].ref);
         pobj = new RAT::DS::UniversalTime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime& obj = ((RAT::DS::UniversalTime*) G__getstructoffset())->operator-=(*(RAT::DS::UniversalTime*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime* pobj;
         const RAT::DS::UniversalTime xobj = ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator-(*(RAT::DS::UniversalTime*) libp->para[0].ref);
         pobj = new RAT::DS::UniversalTime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator==(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator!=(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator<(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator<=(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator>(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::UniversalTime*) G__getstructoffset())->operator>=(*(RAT::DS::UniversalTime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::UniversalTime::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::UniversalTime::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::UniversalTime::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::UniversalTime::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::UniversalTime*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::UniversalTime::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::UniversalTime::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::UniversalTime::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_509_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::UniversalTime::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_509_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::UniversalTime* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::UniversalTime(*(RAT::DS::UniversalTime*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::UniversalTime G__TRATcLcLDScLcLUniversalTime;
static int G__RAT_Dict_509_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::UniversalTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::UniversalTime*) (soff+(sizeof(RAT::DS::UniversalTime)*i)))->~G__TRATcLcLDScLcLUniversalTime();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::UniversalTime*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::UniversalTime*) (soff))->~G__TRATcLcLDScLcLUniversalTime();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_509_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::UniversalTime* dest = (RAT::DS::UniversalTime*) G__getstructoffset();
   *dest = *(RAT::DS::UniversalTime*) libp->para[0].ref;
   const RAT::DS::UniversalTime& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
static int G__RAT_Dict_513_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Cartesian3D<double>* pobj;
         const ROOT::Math::Cartesian3D<double> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Coordinates();
         pobj = new ROOT::Math::Cartesian3D<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[0]), *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[1])
, *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetXYZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator==(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator!=(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetX((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetY((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetR((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetTheta((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetPhi((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetRho((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetEta((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*=((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/=((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator-();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator+();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_513_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_513_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
static int G__RAT_Dict_513_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff+(sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>)*i)))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_513_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* dest = (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset();
   *dest = *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref;
   const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::Cartesian3D<float> */
static int G__RAT_Dict_514_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Cartesian3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::Cartesian3D<float>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::Cartesian3D<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::Cartesian3D<float>;
     } else {
       p = new((void*) gvp) ROOT::Math::Cartesian3D<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Cartesian3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::Cartesian3D<float>(
(ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::Cartesian3D<float>(
(ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Cartesian3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::Cartesian3D<float>(*(ROOT::Math::Cartesian3D<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::Math::Cartesian3D<float>(*(ROOT::Math::Cartesian3D<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Cartesian3D<float>& obj = ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->operator=(*(ROOT::Math::Cartesian3D<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetCoordinates((ROOT::Math::Cartesian3D<float>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->GetCoordinates((ROOT::Math::Cartesian3D<float>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetCoordinates((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::Cartesian3D<float>::Scalar*) G__Floatref(&libp->para[0]), *(ROOT::Math::Cartesian3D<float>::Scalar*) G__Floatref(&libp->para[1])
, *(ROOT::Math::Cartesian3D<float>::Scalar*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetX((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetY((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetZ((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetXYZ((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Scale((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->Negate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->operator==(*(ROOT::Math::Cartesian3D<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->operator!=(*(ROOT::Math::Cartesian3D<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetR((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetTheta((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetPhi((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetRho((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_514_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Cartesian3D<float>*) G__getstructoffset())->SetEta((ROOT::Math::Cartesian3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::Cartesian3D<float> G__TROOTcLcLMathcLcLCartesian3DlEfloatgR;
static int G__RAT_Dict_514_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::Cartesian3D<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::Cartesian3D<float>*) (soff+(sizeof(ROOT::Math::Cartesian3D<float>)*i)))->~G__TROOTcLcLMathcLcLCartesian3DlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::Cartesian3D<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::Cartesian3D<float>*) (soff))->~G__TROOTcLcLMathcLcLCartesian3DlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
static int G__RAT_Dict_515_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Cartesian3D<float>* pobj;
         const ROOT::Math::Cartesian3D<float> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Coordinates();
         pobj = new ROOT::Math::Cartesian3D<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[0]), *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[1])
, *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetXYZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator==(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator!=(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetX((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetY((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetR((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetTheta((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetPhi((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetRho((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetEta((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*=((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/=((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator-();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator+();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_515_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_515_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
static int G__RAT_Dict_515_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff+(sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>)*i)))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_515_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* dest = (ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset();
   *dest = *(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref;
   const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
static int G__RAT_Dict_521_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Polar3D<double>* pobj;
         const ROOT::Math::Polar3D<double> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Coordinates();
         pobj = new ROOT::Math::Polar3D<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[0]), *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[1])
, *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetXYZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator==(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator!=(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetX((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetY((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetR((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetTheta((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetPhi((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetRho((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetEta((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*=((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/=((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator-();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator+();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_521_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_521_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
static int G__RAT_Dict_521_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff+(sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>)*i)))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_521_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>* dest = (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset();
   *dest = *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref;
   const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::Polar3D<float> */
static int G__RAT_Dict_522_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Polar3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::Polar3D<float>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::Polar3D<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::Polar3D<float>;
     } else {
       p = new((void*) gvp) ROOT::Math::Polar3D<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Polar3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::Polar3D<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::Polar3D<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::Polar3D<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::Polar3D<float>(*(ROOT::Math::Polar3D<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) ROOT::Math::Polar3D<float>(*(ROOT::Math::Polar3D<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Polar3D<float>& obj = ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->operator=(*(ROOT::Math::Polar3D<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetCoordinates((ROOT::Math::Polar3D<float>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->GetCoordinates((ROOT::Math::Polar3D<float>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetCoordinates((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::Polar3D<float>::Scalar*) G__Floatref(&libp->para[0]), *(ROOT::Math::Polar3D<float>::Scalar*) G__Floatref(&libp->para[1])
, *(ROOT::Math::Polar3D<float>::Scalar*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetR(*(float*) G__Floatref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetTheta(*(float*) G__Floatref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetPhi(*(float*) G__Floatref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetXYZ((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]), (ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[1])
, (ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->Scale((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->Negate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->operator==(*(ROOT::Math::Polar3D<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->operator!=(*(ROOT::Math::Polar3D<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::Polar3D<float>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetX((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetY((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetZ((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetRho((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_522_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Math::Polar3D<float>*) G__getstructoffset())->SetEta((ROOT::Math::Polar3D<float>::Scalar) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::Polar3D<float> G__TROOTcLcLMathcLcLPolar3DlEfloatgR;
static int G__RAT_Dict_522_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::Polar3D<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::Polar3D<float>*) (soff+(sizeof(ROOT::Math::Polar3D<float>)*i)))->~G__TROOTcLcLMathcLcLPolar3DlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::Polar3D<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::Polar3D<float>*) (soff))->~G__TROOTcLcLMathcLcLPolar3DlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
static int G__RAT_Dict_523_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
     } else {
       p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(
(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::Polar3D<float>* pobj;
         const ROOT::Math::Polar3D<float> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Coordinates();
         pobj = new ROOT::Math::Polar3D<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[0]), *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[1])
, *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->GetCoordinates((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetXYZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]), (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[1])
, (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator==(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator!=(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->Unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetX((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetY((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetZ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetR((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetTheta((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetPhi((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetRho((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->SetEta((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*=((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/=((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator*((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator-();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator+();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->operator/((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar) G__double(libp->para[0]));
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->x());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->r());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->rho());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_523_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* pobj;
         const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> xobj = ((const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset())->unit();
         pobj = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_523_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>(*(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR;
static int G__RAT_Dict_523_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff+(sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>)*i)))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) (soff))->~G__TROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_523_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>* dest = (ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) G__getstructoffset();
   *dest = *(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*) libp->para[0].ref;
   const ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::FitVertex */
static int G__RAT_Dict_539_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitVertex* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitVertex[n];
     } else {
       p = new((void*) gvp) RAT::DS::FitVertex[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitVertex;
     } else {
       p = new((void*) gvp) RAT::DS::FitVertex;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionError(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::XYZVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionErrors(*((const ROOT::Math::Polar3DVectorF*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositionValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositivePositionErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativePositionErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirection(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirection(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirection(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveDirectionError(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveDirectionError(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveDirectionError(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeDirectionError(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeDirectionError(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeDirectionError(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirectionErrors(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirectionErrors(*(TVector3*) libp->para[0].ref, (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirectionErrors(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetDirectionValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveDirectionErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeDirectionErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergy((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergy((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveEnergyError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveEnergyError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveEnergyError((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeEnergyError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeEnergyError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeEnergyError((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergyErrors(*(Double_t*) G__Doubleref(&libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergyErrors(*(Double_t*) G__Doubleref(&libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergyErrors(*(Double_t*) G__Doubleref(&libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetEnergyValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveEnergyErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeEnergyErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTime((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTime((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveTimeError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveTimeError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveTimeError((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeTimeError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeTimeError((const Double_t) G__double(libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeTimeError((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTimeErrors(*(Double_t*) G__Doubleref(&libp->para[0]), (const Bool_t) G__int(libp->para[1])
, (const Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTimeErrors(*(Double_t*) G__Doubleref(&libp->para[0]), (const Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTimeErrors(*(Double_t*) G__Doubleref(&libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetTimeValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetPositiveTimeErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->SetNegativeTimeErrorValid((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetPositivePositionError();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetNegativePositionError();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetDirection();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetPositiveDirectionError();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::FitVertex*) G__getstructoffset())->GetNegativeDirectionError();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetPositiveEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetNegativeEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetPositiveTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetNegativeTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsPositivePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsNegativePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsPositiveDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsNegativeDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsPositiveEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsNegativeEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsPositiveTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsNegativeTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ContainsAny());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidPositivePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidNegativePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidPositiveDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidNegativeDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidPositiveEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidNegativeEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidPositiveTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->ValidNegativeTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetValidityMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->GetValidUnfixed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedPosition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedPositivePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedNegativePositionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedPositiveDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedNegativeDirectionError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedPositiveEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedNegativeEnergyError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedPositiveTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitVertex*) G__getstructoffset())->FixedNegativeTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::FitVertex::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitVertex::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::FitVertex::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::FitVertex::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitVertex*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitVertex::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitVertex::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitVertex::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_539_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitVertex::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_539_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::FitVertex* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::FitVertex(*(RAT::DS::FitVertex*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::FitVertex G__TRATcLcLDScLcLFitVertex;
static int G__RAT_Dict_539_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::FitVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::FitVertex*) (soff+(sizeof(RAT::DS::FitVertex)*i)))->~G__TRATcLcLDScLcLFitVertex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::FitVertex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::FitVertex*) (soff))->~G__TRATcLcLDScLcLFitVertex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_539_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitVertex* dest = (RAT::DS::FitVertex*) G__getstructoffset();
   *dest = *(RAT::DS::FitVertex*) libp->para[0].ref;
   const RAT::DS::FitVertex& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::FitResult */
static int G__RAT_Dict_542_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitResult[n];
     } else {
       p = new((void*) gvp) RAT::DS::FitResult[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitResult;
     } else {
       p = new((void*) gvp) RAT::DS::FitResult;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitResult*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitResult*) G__getstructoffset())->SetVertex((const size_t) G__int(libp->para[0]), *(RAT::DS::FitVertex*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitResult*) G__getstructoffset())->SetFOM(*(string*) libp->para[0].ref, (const Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitResult*) G__getstructoffset())->SetExecutionTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitVertex& obj = ((RAT::DS::FitResult*) G__getstructoffset())->GetVertex((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitVertex& obj = ((const RAT::DS::FitResult*) G__getstructoffset())->GetVertex((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::FitResult*) G__getstructoffset())->GetVertexCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitResult*) G__getstructoffset())->GetFOM(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::FitResult*) G__getstructoffset())->GetFOMNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::FitResult*) G__getstructoffset())->GetExecutionTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitResult*) G__getstructoffset())->GetValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::FitResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::FitResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::FitResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_542_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_542_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::FitResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::FitResult(*(RAT::DS::FitResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::FitResult G__TRATcLcLDScLcLFitResult;
static int G__RAT_Dict_542_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::FitResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::FitResult*) (soff+(sizeof(RAT::DS::FitResult)*i)))->~G__TRATcLcLDScLcLFitResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::FitResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::FitResult*) (soff))->~G__TRATcLcLDScLcLFitResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_542_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitResult* dest = (RAT::DS::FitResult*) G__getstructoffset();
   *dest = *(RAT::DS::FitResult*) libp->para[0].ref;
   const RAT::DS::FitResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > */
static int G__RAT_Dict_546_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reference obj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->at((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_reference obj = ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->at((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator* pobj;
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator xobj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator* pobj;
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator xobj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator* pobj;
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator xobj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator* pobj;
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator xobj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->resize((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->resize((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]), *((RAT::DS::FitVertex*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reference obj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->operator[]((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_reference obj = ((const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->operator[]((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]), *(RAT::DS::FitVertex*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]), *(RAT::DS::FitVertex*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >(*(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >(*(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >& obj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->reserve((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitVertex& obj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitVertex& obj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->push_back(*(RAT::DS::FitVertex*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->swap(*(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator* pobj;
         vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator xobj = ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->insert(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[0])), *(RAT::DS::FitVertex*) libp->para[1].ref);
         pobj = new vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->insert(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->insert(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type) G__int(libp->para[1])
, *(RAT::DS::FitVertex*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->erase(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->erase(*((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_546_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > G__TvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR;
static int G__RAT_Dict_546_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) (soff+(sizeof(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >)*i)))->~G__TvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*) (soff))->~G__TvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::FitClassifierCollection<RAT::DS::FitResult> */
static int G__RAT_Dict_549_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitClassifierCollection<RAT::DS::FitResult>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitClassifierCollection<RAT::DS::FitResult>[n];
     } else {
       p = new((void*) gvp) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitClassifierCollection<RAT::DS::FitResult>;
     } else {
       p = new((void*) gvp) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->GetNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitResult& obj = ((const RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->GetResult(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->ResultExists(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->SetResult(*(string*) libp->para[0].ref, *(RAT::DS::FitResult*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->PruneResult(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_549_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_549_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::FitClassifierCollection<RAT::DS::FitResult>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::FitClassifierCollection<RAT::DS::FitResult>(*(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::FitClassifierCollection<RAT::DS::FitResult> G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR;
static int G__RAT_Dict_549_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) (soff+(sizeof(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>)*i)))->~G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) (soff))->~G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_549_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitClassifierCollection<RAT::DS::FitResult>* dest = (RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) G__getstructoffset();
   *dest = *(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) libp->para[0].ref;
   const RAT::DS::FitClassifierCollection<RAT::DS::FitResult>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> */
static int G__RAT_Dict_558_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>[n];
     } else {
       p = new((void*) gvp) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>;
     } else {
       p = new((void*) gvp) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->GetNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ClassifierResult& obj = ((const RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->GetResult(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->ResultExists(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->SetResult(*(string*) libp->para[0].ref, *(RAT::DS::ClassifierResult*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->PruneResult(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_558_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_558_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>(*(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR;
static int G__RAT_Dict_558_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) (soff+(sizeof(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>)*i)))->~G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) (soff))->~G__TRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_558_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>* dest = (RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) G__getstructoffset();
   *dest = *(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) libp->para[0].ref;
   const RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* json::Value */
static int G__RAT_Dict_683_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new json::Value[n];
     } else {
       p = new((void*) gvp) json::Value[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new json::Value;
     } else {
       p = new((void*) gvp) json::Value;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((json::Type) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((json::Type) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((json::TInteger) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((json::TInteger) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((json::TUInteger) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((json::TUInteger) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((json::TReal) G__double(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((json::TReal) G__double(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((json::TBool) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((json::TBool) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((unsigned int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((unsigned int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value((int) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) json::Value((int) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value(*((json::TString*) G__int(libp->para[0])));
   } else {
     p = new((void*) gvp) json::Value(*((json::TString*) G__int(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value(*((json::TObject*) G__int(libp->para[0])));
   } else {
     p = new((void*) gvp) json::Value(*((json::TObject*) G__int(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value(*((json::TArray*) G__int(libp->para[0])));
   } else {
     p = new((void*) gvp) json::Value(*((json::TArray*) G__int(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   json::Value* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new json::Value(*(json::Value*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) json::Value(*(json::Value*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((json::Value*) G__getstructoffset())->operator=(*(json::Value*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((const json::Value*) G__getstructoffset())->operator[](*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((const json::Value*) G__getstructoffset())->operator[]((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->reset((json::Type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const json::Value*) G__getstructoffset())->getType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const json::Value*) G__getstructoffset())->getInteger());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const json::Value*) G__getstructoffset())->getUInteger());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const json::Value*) G__getstructoffset())->getReal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const json::Value*) G__getstructoffset())->getBool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::TString* pobj;
         const json::TString xobj = ((const json::Value*) G__getstructoffset())->getString();
         pobj = new json::TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((const json::Value*) G__getstructoffset())->getMember(*((json::TString*) G__int(libp->para[0])));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const json::Value*) G__getstructoffset())->getArraySize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((const json::Value*) G__getstructoffset())->getIndex((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const json::Value*) G__getstructoffset())->getMembers();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const json::Value*) G__getstructoffset())->isMember(*((string*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setInteger((json::TInteger) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setUINteger((json::TUInteger) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setReal((json::TReal) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setReal((json::TBool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setString(*((json::TString*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setMember(*((json::TString*) G__int(libp->para[0])), *((json::Value*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setArraySize((size_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((json::Value*) G__getstructoffset())->setIndex((size_t) G__int(libp->para[0]), *((json::Value*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_683_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = ((json::Value*) G__getstructoffset())->toJSONString();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef json::Value G__TjsoncLcLValue;
static int G__RAT_Dict_683_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (json::Value*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((json::Value*) (soff+(sizeof(json::Value)*i)))->~G__TjsoncLcLValue();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (json::Value*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((json::Value*) (soff))->~G__TjsoncLcLValue();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::Log */
static int G__RAT_Dict_701_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) RAT::Log::Init(*((string*) G__int(libp->para[0])), (RAT::Log::Level) G__int(libp->para[1])
, (RAT::Log::Level) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) RAT::Log::Init(*((string*) G__int(libp->para[0])), (RAT::Log::Level) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) RAT::Log::Init(*((string*) G__int(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::Log::GetDisplayLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::Log::GetG4DisplayLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::SetDisplayLevel((RAT::Log::Level) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::Log::GetLogLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::SetLogLevel((RAT::Log::Level) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      RAT::Log::Die(*((string*) G__int(libp->para[0])), (int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      RAT::Log::Die(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      RAT::Log::Assert((bool) G__int(libp->para[0]), *((string*) G__int(libp->para[1]))
, (int) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      RAT::Log::Assert((bool) G__int(libp->para[0]), *((string*) G__int(libp->para[1])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::Log::GetLogBuffer();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::AddMacro(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = RAT::Log::GetMacro();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      RAT::Log::SetDBTraceState((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      RAT::Log::SetDBTraceState();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::Log::GetDBTraceState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (int) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (float) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(string*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(vector<int>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(vector<float>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(vector<std::string>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::TraceDBAccess(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(json::Value*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::Log::GetDBTraceMap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::Log::ClearDBTraceMap();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_701_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::Log* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::Log((TRootIOCtor*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::Log((TRootIOCtor*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_701_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::Log* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::Log(*(RAT::Log*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::Log G__TRATcLcLLog;
static int G__RAT_Dict_701_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::Log*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::Log*) (soff+(sizeof(RAT::Log)*i)))->~G__TRATcLcLLog();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::Log*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::Log*) (soff))->~G__TRATcLcLLog();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_701_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::Log* dest = (RAT::Log*) G__getstructoffset();
   *dest = *(RAT::Log*) libp->para[0].ref;
   const RAT::Log& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::BitManip */
static int G__RAT_Dict_706_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::BitManip* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::BitManip[n];
     } else {
       p = new((void*) gvp) RAT::BitManip[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::BitManip;
     } else {
       p = new((void*) gvp) RAT::BitManip;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCCC((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCrate((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetChannel((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCard((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCCCC((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetLCN((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetLCN((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCell((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCCCwCell((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCratewCell((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetChannelwCell((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetCardwCell((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::GetBits((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) RAT::BitManip::GetBits((UInt_t) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) RAT::BitManip::GetBits((ULong64_t) G__ULonglong(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::ClearBit((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::SetBit((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int>* pobj;
         vector<int> xobj = RAT::BitManip::SetBit(*((vector<int>*) G__int(libp->para[0])), (int) G__int(libp->para[1]));
         pobj = new vector<int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::SetBits((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::SetBit((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (bool) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int>* pobj;
         vector<int> xobj = RAT::BitManip::SetBit(*((vector<int>*) G__int(libp->para[0])), (int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
         pobj = new vector<int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::SetBits((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::TestBit((unsigned int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::TestBit(*((vector<int>*) G__int(libp->para[0])), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::TestBit((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::BitManip::AndWords((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::TestMask((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) RAT::BitManip::FlipBit((unsigned int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) RAT::BitManip::FlipBit((unsigned short) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::BitManip::CopyFlipBit((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, *(int*) G__Intref(&libp->para[2]), (int) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::BitManip::CopyFlipSameBit((int) G__int(libp->para[0]), *(int*) G__Intref(&libp->para[1])
, (int) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::CheckLength((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_706_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::BitManip::CheckLength((UInt_t) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_706_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::BitManip* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::BitManip(*(RAT::BitManip*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::BitManip G__TRATcLcLBitManip;
static int G__RAT_Dict_706_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::BitManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::BitManip*) (soff+(sizeof(RAT::BitManip)*i)))->~G__TRATcLcLBitManip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::BitManip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::BitManip*) (soff))->~G__TRATcLcLBitManip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_706_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::BitManip* dest = (RAT::BitManip*) G__getstructoffset();
   *dest = *(RAT::BitManip*) libp->para[0].ref;
   const RAT::BitManip& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMTCal */
static int G__RAT_Dict_707_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTCal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTCal[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMTCal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTCal;
     } else {
       p = new((void*) gvp) RAT::DS::PMTCal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::PMTCal*) G__getstructoffset())->GetStatus();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((const RAT::DS::PMTCal*) G__getstructoffset())->GetStatus();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTCal*) G__getstructoffset())->SetStatus(*(RAT::DS::BitMask*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTCal*) G__getstructoffset())->SetPMTParameters(
(const UInt_t) G__int(libp->para[0]), (const Double_t) G__double(libp->para[1])
, (const Double_t) G__double(libp->para[2]), (const Double_t) G__double(libp->para[3])
, (const Double_t) G__double(libp->para[4]), (const UShort_t) G__int(libp->para[5])
, (const Char_t) G__int(libp->para[6]), *(RAT::DS::BitMask*) libp->para[7].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMTCal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTCal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMTCal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMTCal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTCal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTCal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTCal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTCal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_707_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTCal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_707_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMTCal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMTCal(*(RAT::DS::PMTCal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMTCal G__TRATcLcLDScLcLPMTCal;
static int G__RAT_Dict_707_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMTCal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMTCal*) (soff+(sizeof(RAT::DS::PMTCal)*i)))->~G__TRATcLcLDScLcLPMTCal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMTCal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMTCal*) (soff))->~G__TRATcLcLDScLcLPMTCal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_707_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTCal* dest = (RAT::DS::PMTCal*) G__getstructoffset();
   *dest = *(RAT::DS::PMTCal*) libp->para[0].ref;
   const RAT::DS::PMTCal& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMT<Double32_t> */
static int G__RAT_Dict_708_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMT<Double32_t>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMT<Double32_t>[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMT<Double32_t>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMT<Double32_t>;
     } else {
       p = new((void*) gvp) RAT::DS::PMT<Double32_t>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetLogicalChannelNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetLCN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCardCrateChannel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCrateCardChannelCell());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCCCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCrate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCard());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetChannel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetQHS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetQHS((const Double32_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetQHL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetQHL((const Double32_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetQLX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetQLX((const Double32_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetTime((const Double32_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCellID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetCellID((const UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetChanFlags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetChanFlags((const Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::PMT<Double32_t>*) G__getstructoffset())->GetCrossTalkFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetCrossTalkFlag((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->SetPMTParameters(
(const UInt_t) G__int(libp->para[0]), (const Double32_t) G__double(libp->para[1])
, (const Double32_t) G__double(libp->para[2]), (const Double32_t) G__double(libp->para[3])
, (const Double32_t) G__double(libp->para[4]), (const UShort_t) G__int(libp->para[5])
, (const Char_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMT<Double32_t>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<Double32_t>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMT<Double32_t>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMT<Double32_t>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<Double32_t>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<Double32_t>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMT<Double32_t>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<Double32_t>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_708_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMT<Double32_t>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_708_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMT<Double32_t>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMT<Double32_t>(*(RAT::DS::PMT<Double32_t>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMT<Double32_t> G__TRATcLcLDScLcLPMTlEDouble32_tgR;
static int G__RAT_Dict_708_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMT<Double32_t>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMT<Double32_t>*) (soff+(sizeof(RAT::DS::PMT<Double32_t>)*i)))->~G__TRATcLcLDScLcLPMTlEDouble32_tgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMT<Double32_t>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMT<Double32_t>*) (soff))->~G__TRATcLcLDScLcLPMTlEDouble32_tgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_708_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMT<Double32_t>* dest = (RAT::DS::PMT<Double32_t>*) G__getstructoffset();
   *dest = *(RAT::DS::PMT<Double32_t>*) libp->para[0].ref;
   const RAT::DS::PMT<Double32_t>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMT<unsigned short> */
static int G__RAT_Dict_709_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMT<unsigned short>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMT<unsigned short>[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMT<unsigned short>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMT<unsigned short>;
     } else {
       p = new((void*) gvp) RAT::DS::PMT<unsigned short>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetLogicalChannelNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetLCN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCardCrateChannel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCrateCardChannelCell());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCCCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCrate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCard());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetChannel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetQHS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetQHS((const unsigned short) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetQHL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetQHL((const unsigned short) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetQLX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetQLX((const unsigned short) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetTime((const unsigned short) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCellID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetCellID((const UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetChanFlags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetChanFlags((const Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::PMT<unsigned short>*) G__getstructoffset())->GetCrossTalkFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetCrossTalkFlag((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->SetPMTParameters(
(const UInt_t) G__int(libp->para[0]), (const unsigned short) G__int(libp->para[1])
, (const unsigned short) G__int(libp->para[2]), (const unsigned short) G__int(libp->para[3])
, (const unsigned short) G__int(libp->para[4]), (const UShort_t) G__int(libp->para[5])
, (const Char_t) G__int(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMT<unsigned short>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<unsigned short>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMT<unsigned short>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMT<unsigned short>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMT<unsigned short>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<unsigned short>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMT<unsigned short>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMT<unsigned short>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_709_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMT<unsigned short>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_709_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMT<unsigned short>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMT<unsigned short>(*(RAT::DS::PMT<unsigned short>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMT<unsigned short> G__TRATcLcLDScLcLPMTlEunsignedsPshortgR;
static int G__RAT_Dict_709_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMT<unsigned short>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMT<unsigned short>*) (soff+(sizeof(RAT::DS::PMT<unsigned short>)*i)))->~G__TRATcLcLDScLcLPMTlEunsignedsPshortgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMT<unsigned short>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMT<unsigned short>*) (soff))->~G__TRATcLcLDScLcLPMTlEunsignedsPshortgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_709_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMT<unsigned short>* dest = (RAT::DS::PMT<unsigned short>*) G__getstructoffset();
   *dest = *(RAT::DS::PMT<unsigned short>*) libp->para[0].ref;
   const RAT::DS::PMT<unsigned short>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCHit */
static int G__RAT_Dict_710_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCHit* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCHit[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCHit[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCHit;
     } else {
       p = new((void*) gvp) RAT::DS::MCHit;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_710_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_710_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCHit(*(RAT::DS::MCHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCHit G__TRATcLcLDScLcLMCHit;
static int G__RAT_Dict_710_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCHit*) (soff+(sizeof(RAT::DS::MCHit)*i)))->~G__TRATcLcLDScLcLMCHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCHit*) (soff))->~G__TRATcLcLDScLcLMCHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_710_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCHit* dest = (RAT::DS::MCHit*) G__getstructoffset();
   *dest = *(RAT::DS::MCHit*) libp->para[0].ref;
   const RAT::DS::MCHit& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::PMTInfo */
static int G__RAT_Dict_712_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PMTInfo*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetType((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetPetalStatus((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetPanelNumber((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetPosition((const size_t) G__int(libp->para[0]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetDirection((const size_t) G__int(libp->para[0]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::PMTInfo*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::PMTInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::PMTInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::PMTInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PMTInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PMTInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_712_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PMTInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_712_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PMTInfo *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PMTInfo[n];
     } else {
       p = new((void*) gvp) RAT::DU::PMTInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PMTInfo;
     } else {
       p = new((void*) gvp) RAT::DU::PMTInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_712_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::PMTInfo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::PMTInfo(*(RAT::DU::PMTInfo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::PMTInfo G__TRATcLcLDUcLcLPMTInfo;
static int G__RAT_Dict_712_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::PMTInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::PMTInfo*) (soff+(sizeof(RAT::DU::PMTInfo)*i)))->~G__TRATcLcLDUcLcLPMTInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::PMTInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::PMTInfo*) (soff))->~G__TRATcLcLDUcLcLPMTInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_712_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PMTInfo* dest = (RAT::DU::PMTInfo*) G__getstructoffset();
   *dest = *(RAT::DU::PMTInfo*) libp->para[0].ref;
   const RAT::DU::PMTInfo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > */
static int G__RAT_Dict_727_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >;
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->Combine(*(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMT<unsigned short>& obj = ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetAllCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNormalCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetOWLCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetLowGainCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetBUTTCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetNeckCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetFECDCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetSpareCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetHQECount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->GetInvalidCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref, (const RAT::DU::PMTInfo::EPMTType) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddNormalPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddOWLPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddLowGainPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddBUTTPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddNeckPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddFECDPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddSparePMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddHQEPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->AddInvalidPMT(*(RAT::DS::PMT<unsigned short>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneAllPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneNormalPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneInwardPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneOWLPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneLowGainPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneBUTTPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneNeckPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneFECDPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneSparePMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneHQEPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->PruneInvalidPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_727_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_727_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >(*(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR;
static int G__RAT_Dict_727_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) (soff+(sizeof(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >)*i)))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) (soff))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_727_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >* dest = (RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) G__getstructoffset();
   *dest = *(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*) libp->para[0].ref;
   const RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMTSet<RAT::DS::PMTCal> */
static int G__RAT_Dict_732_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::PMTCal>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::PMTCal>[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::PMTCal>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::PMTCal>;
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::PMTCal>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->Combine(*(RAT::DS::PMTSet<RAT::DS::PMTCal>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetAllCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNormalCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetOWLCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetLowGainCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetBUTTCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetNeckCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetFECDCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetSpareCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetHQECount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->GetInvalidCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddPMT(*(RAT::DS::PMTCal*) libp->para[0].ref, (const RAT::DU::PMTInfo::EPMTType) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddNormalPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddOWLPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddLowGainPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddBUTTPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddNeckPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddFECDPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddSparePMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddHQEPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->AddInvalidPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneAllPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneNormalPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneInwardPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneOWLPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneLowGainPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneBUTTPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneNeckPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneFECDPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneSparePMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneHQEPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->PruneInvalidPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMTSet<RAT::DS::PMTCal>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_732_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::PMTCal>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_732_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMTSet<RAT::DS::PMTCal>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMTSet<RAT::DS::PMTCal>(*(RAT::DS::PMTSet<RAT::DS::PMTCal>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMTSet<RAT::DS::PMTCal> G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR;
static int G__RAT_Dict_732_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMTSet<RAT::DS::PMTCal>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) (soff+(sizeof(RAT::DS::PMTSet<RAT::DS::PMTCal>)*i)))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMTSet<RAT::DS::PMTCal>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMTSet<RAT::DS::PMTCal>*) (soff))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_732_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::PMTCal>* dest = (RAT::DS::PMTSet<RAT::DS::PMTCal>*) G__getstructoffset();
   *dest = *(RAT::DS::PMTSet<RAT::DS::PMTCal>*) libp->para[0].ref;
   const RAT::DS::PMTSet<RAT::DS::PMTCal>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > */
static int G__RAT_Dict_734_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reference obj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->at((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_reference obj = ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->at((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator* pobj;
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator xobj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator* pobj;
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator xobj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator* pobj;
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator xobj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator* pobj;
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator xobj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->resize((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->resize((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]), *((RAT::DS::PMTCal*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reference obj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->operator[]((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_reference obj = ((const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->operator[]((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]), *(RAT::DS::PMTCal*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]), *(RAT::DS::PMTCal*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >(*(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >(*(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >& obj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->reserve((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTCal& obj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->push_back(*(RAT::DS::PMTCal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->swap(*(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator* pobj;
         vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator xobj = ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->insert(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[0])), *(RAT::DS::PMTCal*) libp->para[1].ref);
         pobj = new vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->insert(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->insert(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type) G__int(libp->para[1])
, *(RAT::DS::PMTCal*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->erase(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->erase(*((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_734_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > G__TvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR;
static int G__RAT_Dict_734_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) (soff+(sizeof(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >)*i)))->~G__TvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*) (soff))->~G__TvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::PMTSet<RAT::DS::MCHit> */
static int G__RAT_Dict_737_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::MCHit>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::MCHit>[n];
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::MCHit>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::PMTSet<RAT::DS::MCHit>;
     } else {
       p = new((void*) gvp) RAT::DS::PMTSet<RAT::DS::MCHit>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->Combine(*(RAT::DS::PMTSet<RAT::DS::MCHit>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetAllPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetPMT((size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNormalPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetOWLPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetLowGainPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetBUTTPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNeckPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetFECDPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetSparePMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetHQEPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHit& obj = ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetInvalidPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetAllCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNormalCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetOWLCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetLowGainCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetBUTTCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetNeckCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetFECDCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetSpareCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetHQECount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->GetInvalidCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddPMT(*(RAT::DS::MCHit*) libp->para[0].ref, (const RAT::DU::PMTInfo::EPMTType) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddNormalPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddOWLPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddLowGainPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddBUTTPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddNeckPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddFECDPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddSparePMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddHQEPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->AddInvalidPMT(*(RAT::DS::MCHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneAllPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneNormalPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneInwardPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneOWLPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneLowGainPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneBUTTPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneNeckPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneFECDPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneSparePMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneHQEPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->PruneInvalidPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::PMTSet<RAT::DS::MCHit>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_737_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::PMTSet<RAT::DS::MCHit>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_737_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::PMTSet<RAT::DS::MCHit>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::PMTSet<RAT::DS::MCHit>(*(RAT::DS::PMTSet<RAT::DS::MCHit>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::PMTSet<RAT::DS::MCHit> G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR;
static int G__RAT_Dict_737_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::PMTSet<RAT::DS::MCHit>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::PMTSet<RAT::DS::MCHit>*) (soff+(sizeof(RAT::DS::PMTSet<RAT::DS::MCHit>)*i)))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::PMTSet<RAT::DS::MCHit>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::PMTSet<RAT::DS::MCHit>*) (soff))->~G__TRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_737_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::PMTSet<RAT::DS::MCHit>* dest = (RAT::DS::PMTSet<RAT::DS::MCHit>*) G__getstructoffset();
   *dest = *(RAT::DS::PMTSet<RAT::DS::MCHit>*) libp->para[0].ref;
   const RAT::DS::PMTSet<RAT::DS::MCHit>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::EV */
static int G__RAT_Dict_742_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::EV* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::EV[n];
     } else {
       p = new((void*) gvp) RAT::DS::EV[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::EV;
     } else {
       p = new((void*) gvp) RAT::DS::EV;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetUniversalTime(*(RAT::DS::UniversalTime*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime* pobj;
         const RAT::DS::UniversalTime xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetUniversalTime();
         pobj = new RAT::DS::UniversalTime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UncalPMTs& obj = ((RAT::DS::EV*) G__getstructoffset())->GetUncalPMTs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UncalPMTs& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetUncalPMTs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::CalPMTs& obj = ((RAT::DS::EV*) G__getstructoffset())->GetCalPMTs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::CalPMTs& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetCalPMTs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetPMTCalType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->AddCalPMTs(*(RAT::DS::CalPMTs*) libp->para[0].ref, (const UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::CalPMTs& obj = ((RAT::DS::EV*) G__getstructoffset())->GetPartialCalPMTs((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::CalPMTs& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetPartialCalPMTs((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<UInt_t>* pobj;
         const vector<UInt_t> xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetPartialPMTCalTypes();
         pobj = new vector<UInt_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::DataQCFlags& obj = ((RAT::DS::EV*) G__getstructoffset())->GetDataCleaningFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::DataQCFlags& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetDataCleaningFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetDefaultFitVertex(*((const string*) G__int(libp->para[0])), *(RAT::DS::FitVertex*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->DefaultFitVertexExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitVertex* pobj;
         const RAT::DS::FitVertex xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetDefaultFitVertex();
         pobj = new RAT::DS::FitVertex(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetDefaultFitName();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->PruneDefaultFit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->AddFitterPass((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitCollection& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetFitResults((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetFitNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitResult& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetFitResult(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->FitResultExists(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetFitResult((UInt_t) G__int(libp->para[0]), *(string*) libp->para[1].ref
, *(RAT::DS::FitResult*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->PruneFitResults((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->AddClassifierPass((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ClassifierCollection& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetClassifierResults((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::EV*) G__getstructoffset())->GetClassifierNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ClassifierResult& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetClassifierResult(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->ClassifierResultExists(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetClassifierResult((UInt_t) G__int(libp->para[0]), *(string*) libp->para[1].ref
, *(RAT::DS::ClassifierResult*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->PruneClassifierResults((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetDigitiser(*(RAT::DS::Digitiser*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Digitiser& obj = ((RAT::DS::EV*) G__getstructoffset())->GetDigitiser();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Digitiser& obj = ((const RAT::DS::EV*) G__getstructoffset())->GetDigitiser();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->DigitiserExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->PruneDigitiser();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetGTID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetGTID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((const RAT::DS::EV*) G__getstructoffset())->GetClockCount50());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetClockCount50((const ULong64_t) G__ULonglong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letULonglong(result7, 109, (G__uint64) ((const RAT::DS::EV*) G__getstructoffset())->GetClockCount10());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetClockCount10((const ULong64_t) G__ULonglong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetClockStat10());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetClockStat10((const Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetESumPeak());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetESumPeak((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetESumDerivative());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetESumDerivative((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetESumIntegral());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetESumIntegral((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetTrigError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetTrigError((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetTrigType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetTrigType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetTubiiTrig());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DS::EV*) G__getstructoffset())->GetTubiiTrigBit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetTubiiTrig((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetTubiiTrigBit((Int_t) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->TUBiiTrigExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetDataSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetDataSet((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::EV*) G__getstructoffset())->GetTotalCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetTotalCharge((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetNhits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetNhits((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetNhitsCleaned());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetNhitsCleaned((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::EV*) G__getstructoffset())->GetInTimeHits100());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetInTimeHits100((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::EV*) G__getstructoffset())->GetInTimeHits20());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetInTimeHits20((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetCalibrationEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetCalibrationEvent((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::EV*) G__getstructoffset())->GetPollingEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->SetPollingEvent((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::EV::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::EV::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::EV::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::EV::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::EV*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::EV::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::EV::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::EV::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_742_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::EV::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_742_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::EV* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::EV(*(RAT::DS::EV*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::EV G__TRATcLcLDScLcLEV;
static int G__RAT_Dict_742_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::EV*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::EV*) (soff+(sizeof(RAT::DS::EV)*i)))->~G__TRATcLcLDScLcLEV();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::EV*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::EV*) (soff))->~G__TRATcLcLDScLcLEV();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_742_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::EV* dest = (RAT::DS::EV*) G__getstructoffset();
   *dest = *(RAT::DS::EV*) libp->para[0].ref;
   const RAT::DS::EV& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > */
static int G__RAT_Dict_745_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >[n];
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >;
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >(*(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >& obj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->operator=(*(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->begin();
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->end();
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->rbegin();
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->rend();
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::PMTSet<RAT::DS::PMTCal>& obj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->operator[](*(unsigned int*) G__UIntref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator,bool>* pobj;
         pair<map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator,bool> xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->insert(*(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])), *(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::value_type*) libp->para[1].ref);
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->erase(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->swap(*(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->find(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->count(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->lower_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_745_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator xobj = ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) G__getstructoffset())->upper_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > G__TmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR;
static int G__RAT_Dict_745_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) (soff+(sizeof(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >)*i)))->~G__TmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*) (soff))->~G__TmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > */
static int G__RAT_Dict_746_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[n];
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >;
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_746_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::PMTSet<RAT::DS::PMTCal>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::PMTSet<RAT::DS::PMTCal>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_746_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >(*(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > G__TpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR;
static int G__RAT_Dict_746_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*) (soff+(sizeof(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >)*i)))->~G__TpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*) (soff))->~G__TpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > */
static int G__RAT_Dict_752_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >[n];
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >;
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >& obj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->operator=(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->begin();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->end();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->rbegin();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->rend();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitClassifierCollection<RAT::DS::FitResult>& obj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->operator[](*(unsigned int*) G__UIntref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator,bool>* pobj;
         pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator,bool> xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->insert(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])), *(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::value_type*) libp->para[1].ref);
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->erase(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->swap(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->find(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->count(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->lower_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_752_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) G__getstructoffset())->upper_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR;
static int G__RAT_Dict_752_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) (soff+(sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >)*i)))->~G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*) (soff))->~G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > */
static int G__RAT_Dict_753_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[n];
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >;
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_753_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_753_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >(*(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR;
static int G__RAT_Dict_753_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*) (soff+(sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >)*i)))->~G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*) (soff))->~G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > */
static int G__RAT_Dict_759_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >[n];
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >;
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >& obj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->operator=(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->begin();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->end();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->rbegin();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->rend();
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>& obj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->operator[](*(unsigned int*) G__UIntref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator,bool>* pobj;
         pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator,bool> xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->insert(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])), *(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::value_type*) libp->para[1].ref);
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->erase(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->swap(*(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->find(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->count(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->lower_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_759_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator* pobj;
         map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator xobj = ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) G__getstructoffset())->upper_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR;
static int G__RAT_Dict_759_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) (soff+(sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >)*i)))->~G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*) (soff))->~G__TmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > */
static int G__RAT_Dict_760_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[n];
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >;
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_760_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_760_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >(*(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR;
static int G__RAT_Dict_760_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*) (soff+(sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >)*i)))->~G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*) (soff))->~G__TpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::TrigHeader */
static int G__RAT_Dict_768_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::TrigHeader* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::TrigHeader[n];
     } else {
       p = new((void*) gvp) RAT::DS::TrigHeader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::TrigHeader;
     } else {
       p = new((void*) gvp) RAT::DS::TrigHeader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetTrigMask((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetTrigMask());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetPulserRate((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetPulserRate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetMTC_CSR((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetMTC_CSR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetLockoutWidth((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetLockoutWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetPrescaleFrequency((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetPrescaleFrequency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetTriggerThreshold((const UShort_t) G__int(libp->para[0]), (const UShort_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetTriggerThreshold((const UShort_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->SetTrigZeroOffset((const UShort_t) G__int(libp->para[0]), (const UShort_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::TrigHeader*) G__getstructoffset())->GetTriggerZeroOffset((const UShort_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::TrigHeader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::TrigHeader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::TrigHeader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::TrigHeader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::TrigHeader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::TrigHeader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::TrigHeader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::TrigHeader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_768_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::TrigHeader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_768_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::TrigHeader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::TrigHeader(*(RAT::DS::TrigHeader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::TrigHeader G__TRATcLcLDScLcLTrigHeader;
static int G__RAT_Dict_768_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::TrigHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::TrigHeader*) (soff+(sizeof(RAT::DS::TrigHeader)*i)))->~G__TRATcLcLDScLcLTrigHeader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::TrigHeader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::TrigHeader*) (soff))->~G__TRATcLcLDScLcLTrigHeader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_768_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::TrigHeader* dest = (RAT::DS::TrigHeader*) G__getstructoffset();
   *dest = *(RAT::DS::TrigHeader*) libp->para[0].ref;
   const RAT::DS::TrigHeader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::HeaderInfo */
static int G__RAT_Dict_777_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::HeaderInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::HeaderInfo[n];
     } else {
       p = new((void*) gvp) RAT::DS::HeaderInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::HeaderInfo;
     } else {
       p = new((void*) gvp) RAT::DS::HeaderInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::HeaderInfo*) G__getstructoffset())->SetECAHeader(*(RAT::DS::ECAHeader*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::HeaderInfo*) G__getstructoffset())->ECAHeaderExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ECAHeader& obj = ((RAT::DS::HeaderInfo*) G__getstructoffset())->GetECAHeader();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ECAHeader& obj = ((const RAT::DS::HeaderInfo*) G__getstructoffset())->GetECAHeader();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::HeaderInfo*) G__getstructoffset())->PruneECAHeader();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::HeaderInfo*) G__getstructoffset())->SetTrigHeader(*(RAT::DS::TrigHeader*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::HeaderInfo*) G__getstructoffset())->TrigHeaderExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::TrigHeader& obj = ((RAT::DS::HeaderInfo*) G__getstructoffset())->GetTrigHeader();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::TrigHeader& obj = ((const RAT::DS::HeaderInfo*) G__getstructoffset())->GetTrigrHeader();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::HeaderInfo*) G__getstructoffset())->PruneTrigHeader();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::HeaderInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::HeaderInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::HeaderInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::HeaderInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::HeaderInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::HeaderInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::HeaderInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::HeaderInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_777_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::HeaderInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_777_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::HeaderInfo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::HeaderInfo(*(RAT::DS::HeaderInfo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::HeaderInfo G__TRATcLcLDScLcLHeaderInfo;
static int G__RAT_Dict_777_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::HeaderInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::HeaderInfo*) (soff+(sizeof(RAT::DS::HeaderInfo)*i)))->~G__TRATcLcLDScLcLHeaderInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::HeaderInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::HeaderInfo*) (soff))->~G__TRATcLcLDScLcLHeaderInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_777_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::HeaderInfo* dest = (RAT::DS::HeaderInfo*) G__getstructoffset();
   *dest = *(RAT::DS::HeaderInfo*) libp->para[0].ref;
   const RAT::DS::HeaderInfo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > */
static int G__RAT_Dict_779_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reference obj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->at((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_reference obj = ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->at((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator* pobj;
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator xobj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator* pobj;
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator xobj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator* pobj;
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator xobj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator* pobj;
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator xobj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->resize((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->resize((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]), *((RAT::DS::ECAHeader*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reference obj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->operator[]((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_reference obj = ((const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->operator[]((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]), *(RAT::DS::ECAHeader*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]), *(RAT::DS::ECAHeader*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >(*(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >(*(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >& obj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->reserve((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ECAHeader& obj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::ECAHeader& obj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->push_back(*(RAT::DS::ECAHeader*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->swap(*(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator* pobj;
         vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator xobj = ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[0])), *(RAT::DS::ECAHeader*) libp->para[1].ref);
         pobj = new vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type) G__int(libp->para[1])
, *(RAT::DS::ECAHeader*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->erase(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->erase(*((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_779_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > G__TvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR;
static int G__RAT_Dict_779_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) (soff+(sizeof(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >)*i)))->~G__TvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*) (soff))->~G__TvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > */
static int G__RAT_Dict_783_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reference obj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->at((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_reference obj = ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->at((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator* pobj;
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator xobj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator* pobj;
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator xobj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator* pobj;
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator xobj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator* pobj;
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator xobj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->resize((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->resize((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]), *((RAT::DS::TrigHeader*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reference obj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->operator[]((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_reference obj = ((const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->operator[]((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]), *(RAT::DS::TrigHeader*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]), *(RAT::DS::TrigHeader*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >(*(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >(*(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >& obj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->reserve((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::TrigHeader& obj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::TrigHeader& obj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->push_back(*(RAT::DS::TrigHeader*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->swap(*(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator* pobj;
         vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator xobj = ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[0])), *(RAT::DS::TrigHeader*) libp->para[1].ref);
         pobj = new vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->insert(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type) G__int(libp->para[1])
, *(RAT::DS::TrigHeader*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->erase(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->erase(*((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_783_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > G__TvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR;
static int G__RAT_Dict_783_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) (soff+(sizeof(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >)*i)))->~G__TvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*) (soff))->~G__TvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MetaDB */
static int G__RAT_Dict_786_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MetaDB* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MetaDB[n];
     } else {
       p = new((void*) gvp) RAT::DS::MetaDB[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MetaDB;
     } else {
       p = new((void*) gvp) RAT::DS::MetaDB;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MetaDB*) G__getstructoffset())->AddOverrideCommand(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MetaDB*) G__getstructoffset())->AddFile(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<std::string,std::string>* pobj;
         const pair<std::string,std::string> xobj = ((const RAT::DS::MetaDB*) G__getstructoffset())->GetOverrideCommand((const size_t) G__int(libp->para[0]));
         pobj = new pair<std::string,std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MetaDB*) G__getstructoffset())->GetOverrideCommandCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MetaDB*) G__getstructoffset())->GetFile((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MetaDB*) G__getstructoffset())->GetFileCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MetaDB::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MetaDB::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MetaDB::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MetaDB::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MetaDB*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MetaDB::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MetaDB::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MetaDB::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_786_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MetaDB::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_786_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MetaDB* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MetaDB(*(RAT::DS::MetaDB*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MetaDB G__TRATcLcLDScLcLMetaDB;
static int G__RAT_Dict_786_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MetaDB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MetaDB*) (soff+(sizeof(RAT::DS::MetaDB)*i)))->~G__TRATcLcLDScLcLMetaDB();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MetaDB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MetaDB*) (soff))->~G__TRATcLcLDScLcLMetaDB();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_786_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MetaDB* dest = (RAT::DS::MetaDB*) G__getstructoffset();
   *dest = *(RAT::DS::MetaDB*) libp->para[0].ref;
   const RAT::DS::MetaDB& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<string,string> */
static int G__RAT_Dict_787_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<string,string>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<string,string>[n];
     } else {
       p = new((void*) gvp) pair<string,string>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<string,string>;
     } else {
       p = new((void*) gvp) pair<string,string>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_787_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<string,string>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<string,string>(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<string,string>(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_787_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<string,string>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<string,string>(*(pair<string,string>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<string,string> G__TpairlEstringcOstringgR;
static int G__RAT_Dict_787_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<string,string>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<string,string>*) (soff+(sizeof(pair<string,string>)*i)))->~G__TpairlEstringcOstringgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<string,string>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<string,string>*) (soff))->~G__TpairlEstringcOstringgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::Run */
static int G__RAT_Dict_792_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Run* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Run[n];
     } else {
       p = new((void*) gvp) RAT::DS::Run[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Run;
     } else {
       p = new((void*) gvp) RAT::DS::Run;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetRunID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetSubRunID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetSubRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetDate((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetDate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetTime((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetRunType((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetRunType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetFirstGTID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetFirstGTID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetValidGTID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetValidGTID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetBuilderVersion(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::Run*) G__getstructoffset())->GetBuilderVersion();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::DataQCFlags& obj = ((RAT::DS::Run*) G__getstructoffset())->GetDataQualityFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::DataQCFlags& obj = ((const RAT::DS::Run*) G__getstructoffset())->GetDataQualityFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->IncrementNMCEvents();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetNMCEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::DS::Run*) G__getstructoffset())->SetMCFlag((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::DS::Run*) G__getstructoffset())->SetMCFlag();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::Run*) G__getstructoffset())->GetRunLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetRunLength((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetMCFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetDigitiserTrigSums(*((const vector<Int_t>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetDigitiserTrigSum((const size_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>* pobj;
         const vector<Int_t> xobj = ((const RAT::DS::Run*) G__getstructoffset())->GetDigitiserTrigSums();
         pobj = new vector<Int_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::Run*) G__getstructoffset())->GetDigitiserTrigSum((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->PruneDigitiserTrigSums();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Run*) G__getstructoffset())->SOCDataExists(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetSOCData(*(string*) libp->para[0].ref, *(RAT::DS::SOC*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOC& obj = ((RAT::DS::Run*) G__getstructoffset())->GetSOCData(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOC& obj = ((const RAT::DS::Run*) G__getstructoffset())->GetSOCData(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::Run*) G__getstructoffset())->GetSOCSourceIDs();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Run*) G__getstructoffset())->CSSBitsExist((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->SetCSSBits((const UInt_t) G__int(libp->para[0]), *(RAT::DS::BitMask*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((RAT::DS::Run*) G__getstructoffset())->GetCSSBits((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask& obj = ((const RAT::DS::Run*) G__getstructoffset())->GetCSSBits((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::Run::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Run::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::Run::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::Run::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Run*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Run::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Run::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Run::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_792_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Run::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_792_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::Run* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::Run(*(RAT::DS::Run*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::Run G__TRATcLcLDScLcLRun;
static int G__RAT_Dict_792_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::Run*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::Run*) (soff+(sizeof(RAT::DS::Run)*i)))->~G__TRATcLcLDScLcLRun();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::Run*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::Run*) (soff))->~G__TRATcLcLDScLcLRun();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_792_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Run* dest = (RAT::DS::Run*) G__getstructoffset();
   *dest = *(RAT::DS::Run*) libp->para[0].ref;
   const RAT::DS::Run& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::Meta */
static int G__RAT_Dict_793_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Meta* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Meta[n];
     } else {
       p = new((void*) gvp) RAT::DS::Meta[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Meta;
     } else {
       p = new((void*) gvp) RAT::DS::Meta;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Meta*) G__getstructoffset())->NewPass(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref, *(string*) libp->para[5].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Meta*) G__getstructoffset())->CompletePass(*(RAT::MetaHelper*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::Meta*) G__getstructoffset())->GetCurrentPass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::Meta*) G__getstructoffset())->GetPassCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MetaDB& obj = ((RAT::DS::Meta*) G__getstructoffset())->GetMetaDB((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MetaDB& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetMetaDB((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MetaDB>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetMetaDBs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetHostNames();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetHostSystems();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetVersions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetRevisions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetGeant4Versions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetRootVersions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetContainsMCFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetContainsDataFlags();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetEventsGeneratedCounts();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Int_t>& obj = ((const RAT::DS::Meta*) G__getstructoffset())->GetEventsStoredCounts();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::Meta::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Meta::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::Meta::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::Meta::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Meta*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Meta::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Meta::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Meta::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_793_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Meta::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_793_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::Meta* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::Meta(*(RAT::DS::Meta*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::Meta G__TRATcLcLDScLcLMeta;
static int G__RAT_Dict_793_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::Meta*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::Meta*) (soff+(sizeof(RAT::DS::Meta)*i)))->~G__TRATcLcLDScLcLMeta();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::Meta*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::Meta*) (soff))->~G__TRATcLcLDScLcLMeta();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_793_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Meta* dest = (RAT::DS::Meta*) G__getstructoffset();
   *dest = *(RAT::DS::Meta*) libp->para[0].ref;
   const RAT::DS::Meta& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > */
static int G__RAT_Dict_796_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reference obj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->at((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_reference obj = ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->at((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator* pobj;
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator xobj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator* pobj;
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator xobj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator* pobj;
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator xobj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator* pobj;
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator xobj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->resize((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->resize((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]), *((RAT::DS::MetaDB*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reference obj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_reference obj = ((const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]), *(RAT::DS::MetaDB*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]), *(RAT::DS::MetaDB*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >(*(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >(*(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >& obj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->reserve((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MetaDB& obj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MetaDB& obj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->push_back(*(RAT::DS::MetaDB*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator* pobj;
         vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator xobj = ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MetaDB*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MetaDB*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_796_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > G__TvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR;
static int G__RAT_Dict_796_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) (soff+(sizeof(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >)*i)))->~G__TvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*) (soff))->~G__TvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCParticle */
static int G__RAT_Dict_799_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCParticle* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCParticle[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCParticle[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCParticle;
     } else {
       p = new((void*) gvp) RAT::DS::MCParticle;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCParticle*) G__getstructoffset())->GetPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetPolarisation(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCParticle*) G__getstructoffset())->GetPolarisation();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetMomentum(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCParticle*) G__getstructoffset())->GetMomentum();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetPDGCode((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCParticle*) G__getstructoffset())->GetPDGCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCParticle*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetKineticEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCParticle*) G__getstructoffset())->GetKineticEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetVertexID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCParticle*) G__getstructoffset())->GetVertexID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->SetMetaInfo(*((const string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCParticle*) G__getstructoffset())->GetMetaInfo();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCParticle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCParticle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCParticle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCParticle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCParticle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCParticle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCParticle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCParticle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_799_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCParticle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_799_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCParticle* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCParticle(*(RAT::DS::MCParticle*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCParticle G__TRATcLcLDScLcLMCParticle;
static int G__RAT_Dict_799_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCParticle*) (soff+(sizeof(RAT::DS::MCParticle)*i)))->~G__TRATcLcLDScLcLMCParticle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCParticle*) (soff))->~G__TRATcLcLDScLcLMCParticle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_799_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCParticle* dest = (RAT::DS::MCParticle*) G__getstructoffset();
   *dest = *(RAT::DS::MCParticle*) libp->para[0].ref;
   const RAT::DS::MCParticle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCTrackStep */
static int G__RAT_Dict_800_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCTrackStep* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCTrackStep[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCTrackStep[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCTrackStep;
     } else {
       p = new((void*) gvp) RAT::DS::MCTrackStep;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetPolarisation(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetPolarisation();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetMomentum(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetMomentum();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetStartVolume(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetStartVolume();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetEndVolume(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetEndVolume();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetLength((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetGlobalTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetGlobalTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetLocalTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetLocalTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetProperTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetProperTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetKineticEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetKineticEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetDepositedEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetDepositedEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetStatus((const RAT::DS::MCTrackStep::EStatus) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetStatus();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->SetProcess(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetProcess();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCTrackStep*) G__getstructoffset())->GetProcessEnum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCTrackStep::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrackStep::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCTrackStep::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCTrackStep::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrackStep*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrackStep::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCTrackStep::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrackStep::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_800_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCTrackStep::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_800_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCTrackStep* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCTrackStep(*(RAT::DS::MCTrackStep*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCTrackStep G__TRATcLcLDScLcLMCTrackStep;
static int G__RAT_Dict_800_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCTrackStep*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCTrackStep*) (soff+(sizeof(RAT::DS::MCTrackStep)*i)))->~G__TRATcLcLDScLcLMCTrackStep();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCTrackStep*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCTrackStep*) (soff))->~G__TRATcLcLDScLcLMCTrackStep();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_800_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCTrackStep* dest = (RAT::DS::MCTrackStep*) G__getstructoffset();
   *dest = *(RAT::DS::MCTrackStep*) libp->para[0].ref;
   const RAT::DS::MCTrackStep& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCTrack */
static int G__RAT_Dict_803_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCTrack[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCTrack;
     } else {
       p = new((void*) gvp) RAT::DS::MCTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetTrackID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetTrackID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetParentID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetParentID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetPDGCode((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetPDGCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetParticleName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::MCTrack*) G__getstructoffset())->GetParticleName();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetLength((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetDepositedEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetDepositedEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetWeight((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetSummaryFlag((const RAT::DS::MCTrack::ESummaryFlag) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::MCTrack*) G__getstructoffset())->SetSummaryFlag((const RAT::DS::MCTrack::ESummaryFlag) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetSummaryFlag((const RAT::DS::MCTrack::ESummaryFlag) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->AddMCTrackStep(*(RAT::DS::MCTrackStep*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MCTrack*) G__getstructoffset())->GetMCTrackStepCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((const RAT::DS::MCTrack*) G__getstructoffset())->GetFirstMCTrackStep();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((RAT::DS::MCTrack*) G__getstructoffset())->GetMCTrackStep((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((const RAT::DS::MCTrack*) G__getstructoffset())->GetMCTrackStep((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((const RAT::DS::MCTrack*) G__getstructoffset())->GetLastMCTrackStep();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->PruneMCTrackSteps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->PruneMCTrackStepsByIndex(*(set<size_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->PruneIntermediateMCTrackSteps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_803_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_803_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCTrack(*(RAT::DS::MCTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCTrack G__TRATcLcLDScLcLMCTrack;
static int G__RAT_Dict_803_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCTrack*) (soff+(sizeof(RAT::DS::MCTrack)*i)))->~G__TRATcLcLDScLcLMCTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCTrack*) (soff))->~G__TRATcLcLDScLcLMCTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_803_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCTrack* dest = (RAT::DS::MCTrack*) G__getstructoffset();
   *dest = *(RAT::DS::MCTrack*) libp->para[0].ref;
   const RAT::DS::MCTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > */
static int G__RAT_Dict_812_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reference obj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->at((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_reference obj = ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->at((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator* pobj;
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator xobj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator* pobj;
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator xobj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator* pobj;
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator xobj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator* pobj;
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator xobj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->resize((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->resize((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCTrackStep*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reference obj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_reference obj = ((const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCTrackStep*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCTrackStep*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >(*(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >(*(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >& obj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrackStep& obj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->push_back(*(RAT::DS::MCTrackStep*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator* pobj;
         vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator xobj = ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCTrackStep*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCTrackStep*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_812_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > G__TvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR;
static int G__RAT_Dict_812_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) (soff+(sizeof(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >)*i)))->~G__TvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCPhoton */
static int G__RAT_Dict_815_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPhoton* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPhoton[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCPhoton[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPhoton;
     } else {
       p = new((void*) gvp) RAT::DS::MCPhoton;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetInPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetInPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetInDirection(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetInDirection();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetInPolarisation(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetInPolarisation();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetInTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetInTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetOutPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetOutPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetOutDirection(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetOutDirection();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetOutPolarisation(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetOutPolarisation();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetOutTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetOutTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetEnergy((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetWeight((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetPhotonTrackID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetPhotonTrackID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetPMTID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetPMTID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->SetFate((RAT::DS::MCPhoton::EPhotonFate) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCPhoton*) G__getstructoffset())->GetFate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCPhoton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPhoton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCPhoton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCPhoton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPhoton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPhoton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPhoton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPhoton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_815_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPhoton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_815_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCPhoton* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCPhoton(*(RAT::DS::MCPhoton*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCPhoton G__TRATcLcLDScLcLMCPhoton;
static int G__RAT_Dict_815_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCPhoton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCPhoton*) (soff+(sizeof(RAT::DS::MCPhoton)*i)))->~G__TRATcLcLDScLcLMCPhoton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCPhoton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCPhoton*) (soff))->~G__TRATcLcLDScLcLMCPhoton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_815_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPhoton* dest = (RAT::DS::MCPhoton*) G__getstructoffset();
   *dest = *(RAT::DS::MCPhoton*) libp->para[0].ref;
   const RAT::DS::MCPhoton& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCPE */
static int G__RAT_Dict_818_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPE* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPE[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCPE[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPE;
     } else {
       p = new((void*) gvp) RAT::DS::MCPE;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetPosition(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DS::MCPE*) G__getstructoffset())->GetPosition();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetCreationTime((const double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPE*) G__getstructoffset())->GetCreationTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetFrontEndTime((const double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPE*) G__getstructoffset())->GetFrontEndTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetCharge((const double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCPE*) G__getstructoffset())->GetCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetPhotonTrackID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MCPE*) G__getstructoffset())->GetPhotonTrackID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::DS::MCPE*) G__getstructoffset())->SetNoise((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::DS::MCPE*) G__getstructoffset())->SetNoise();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::MCPE*) G__getstructoffset())->GetNoise());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 114, (long) ((const RAT::DS::MCPE*) G__getstructoffset())->GetHistory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RAT::DS::MCPE*) G__getstructoffset())->AddToHistory((RAT::DS::MCPE::PhotonHistory) G__int(libp->para[0]), (RAT::DS::MCPE::PhHistoryStatus) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DS::MCPE*) G__getstructoffset())->AddToHistory((RAT::DS::MCPE::PhotonHistory) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->SetHistory((UShort_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::MCPE*) G__getstructoffset())->GetFromHistory((RAT::DS::MCPE::PhotonHistory) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::DS::MCPE*) G__getstructoffset())->SetAfterPulse((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::DS::MCPE*) G__getstructoffset())->SetAfterPulse();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::MCPE*) G__getstructoffset())->GetAfterPulse());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCPE::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPE::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCPE::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCPE::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPE*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPE::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPE::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPE::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_818_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPE::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_818_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCPE* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCPE(*(RAT::DS::MCPE*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCPE G__TRATcLcLDScLcLMCPE;
static int G__RAT_Dict_818_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCPE*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCPE*) (soff+(sizeof(RAT::DS::MCPE)*i)))->~G__TRATcLcLDScLcLMCPE();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCPE*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCPE*) (soff))->~G__TRATcLcLDScLcLMCPE();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_818_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPE* dest = (RAT::DS::MCPE*) G__getstructoffset();
   *dest = *(RAT::DS::MCPE*) libp->para[0].ref;
   const RAT::DS::MCPE& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCPMT */
static int G__RAT_Dict_822_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPMT[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCPMT[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCPMT;
     } else {
       p = new((void*) gvp) RAT::DS::MCPMT;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DS::MCPMT((const UInt_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::DS::MCPMT((const UInt_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MCPMT*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->SetID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPhoton& obj = ((RAT::DS::MCPMT*) G__getstructoffset())->GetMCPhoton((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPhoton& obj = ((const RAT::DS::MCPMT*) G__getstructoffset())->GetMCPhoton((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MCPMT*) G__getstructoffset())->GetMCPhotonCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->AddMCPhoton(*(RAT::DS::MCPhoton*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->PruneMCPhotons();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPE& obj = ((RAT::DS::MCPMT*) G__getstructoffset())->GetMCPE((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPE& obj = ((const RAT::DS::MCPMT*) G__getstructoffset())->GetMCPE((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MCPMT*) G__getstructoffset())->GetMCPECount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->AddMCPE(*(RAT::DS::MCPE*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->PruneMCPEs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->SortMCPEs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCPMT::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPMT::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCPMT::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCPMT::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCPMT*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPMT::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPMT::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCPMT::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_822_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCPMT::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_822_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCPMT* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCPMT(*(RAT::DS::MCPMT*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCPMT G__TRATcLcLDScLcLMCPMT;
static int G__RAT_Dict_822_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCPMT*) (soff+(sizeof(RAT::DS::MCPMT)*i)))->~G__TRATcLcLDScLcLMCPMT();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCPMT*) (soff))->~G__TRATcLcLDScLcLMCPMT();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_822_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCPMT* dest = (RAT::DS::MCPMT*) G__getstructoffset();
   *dest = *(RAT::DS::MCPMT*) libp->para[0].ref;
   const RAT::DS::MCPMT& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > */
static int G__RAT_Dict_824_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reference obj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->at((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_reference obj = ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->at((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator* pobj;
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator xobj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator* pobj;
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator xobj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator xobj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator xobj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCPhoton*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reference obj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_reference obj = ((const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPhoton*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPhoton*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >(*(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >(*(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >& obj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPhoton& obj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPhoton& obj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->push_back(*(RAT::DS::MCPhoton*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator* pobj;
         vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator xobj = ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCPhoton*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCPhoton*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_824_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > G__TvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR;
static int G__RAT_Dict_824_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) (soff+(sizeof(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >)*i)))->~G__TvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > */
static int G__RAT_Dict_828_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reference obj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->at((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_reference obj = ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->at((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator* pobj;
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator xobj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator* pobj;
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator xobj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator xobj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator xobj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCPE*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reference obj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_reference obj = ((const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPE*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPE*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >(*(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >(*(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >& obj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPE& obj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPE& obj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->push_back(*(RAT::DS::MCPE*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator* pobj;
         vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator xobj = ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCPE*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCPE*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_828_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > G__TvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR;
static int G__RAT_Dict_828_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) (soff+(sizeof(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >)*i)))->~G__TvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MC */
static int G__RAT_Dict_831_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MC* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MC[n];
     } else {
       p = new((void*) gvp) RAT::DS::MC[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MC;
     } else {
       p = new((void*) gvp) RAT::DS::MC;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetMCID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetMCTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MC*) G__getstructoffset())->GetMCTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetUniversalTime(*(RAT::DS::UniversalTime*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::UniversalTime* pobj;
         const RAT::DS::UniversalTime xobj = ((const RAT::DS::MC*) G__getstructoffset())->GetUniversalTime();
         pobj = new RAT::DS::UniversalTime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->AddMCParent(*(RAT::DS::MCParticle*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCParentCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((RAT::DS::MC*) G__getstructoffset())->GetMCParent((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((const RAT::DS::MC*) G__getstructoffset())->GetMCParent((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->PruneMCParents();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->AddMCParticle(*(RAT::DS::MCParticle*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCParticleCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((RAT::DS::MC*) G__getstructoffset())->GetMCParticle((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((const RAT::DS::MC*) G__getstructoffset())->GetMCParticle((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->PruneMCParticles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->AddMCTrack(*(RAT::DS::MCTrack*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCTrackCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<unsigned int>* pobj;
         const vector<unsigned int> xobj = ((const RAT::DS::MC*) G__getstructoffset())->GetMCTrackIDs();
         pobj = new vector<unsigned int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrack& obj = ((RAT::DS::MC*) G__getstructoffset())->GetMCTrack((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrack& obj = ((const RAT::DS::MC*) G__getstructoffset())->GetMCTrack((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrack& obj = ((RAT::DS::MC*) G__getstructoffset())->GetMCTrackFromIndex((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((RAT::DS::MC*) G__getstructoffset())->GetMCTrackID((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->PruneMCTracks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->PruneMCTracksByIndex(*(set<size_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->AddMCPMT(*(RAT::DS::MCPMT*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCPMTCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPMT& obj = ((RAT::DS::MC*) G__getstructoffset())->GetMCPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPMT& obj = ((const RAT::DS::MC*) G__getstructoffset())->GetMCPMT((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->PruneMCPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHits& obj = ((RAT::DS::MC*) G__getstructoffset())->GetUnbuiltMCHits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHits& obj = ((const RAT::DS::MC*) G__getstructoffset())->GetUnbuiltMCHits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetMCPECount((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetMCPECount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetNumDirPE((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetNumDirPE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetNCherPhotons((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetNCherPhotons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetNScintPhotons((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetNScintPhotons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetNReemittedPhotons((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::MC*) G__getstructoffset())->GetNReemittedPhotons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetInitialScintTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MC*) G__getstructoffset())->GetInitialScintTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetScintEnergyDeposit((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MC*) G__getstructoffset())->GetScintEnergyDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->SetScintQuenchedEnergyDeposit((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MC*) G__getstructoffset())->GetScintQuenchedEnergyDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MC::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MC::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MC::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MC::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MC*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MC::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MC::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MC::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_831_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MC::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_831_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MC* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MC(*(RAT::DS::MC*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MC G__TRATcLcLDScLcLMC;
static int G__RAT_Dict_831_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MC*) (soff+(sizeof(RAT::DS::MC)*i)))->~G__TRATcLcLDScLcLMC();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MC*) (soff))->~G__TRATcLcLDScLcLMC();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_831_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MC* dest = (RAT::DS::MC*) G__getstructoffset();
   *dest = *(RAT::DS::MC*) libp->para[0].ref;
   const RAT::DS::MC& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > */
static int G__RAT_Dict_833_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reference obj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->at((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_reference obj = ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->at((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator* pobj;
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator xobj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator* pobj;
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator xobj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator* pobj;
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator xobj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator* pobj;
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator xobj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->resize((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->resize((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCParticle*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reference obj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_reference obj = ((const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCParticle*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCParticle*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >(*(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >(*(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >& obj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCParticle& obj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->push_back(*(RAT::DS::MCParticle*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator* pobj;
         vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator xobj = ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCParticle*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCParticle*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_833_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > G__TvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR;
static int G__RAT_Dict_833_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) (soff+(sizeof(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >)*i)))->~G__TvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > */
static int G__RAT_Dict_837_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reference obj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->at((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_reference obj = ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->at((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator* pobj;
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator xobj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator* pobj;
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator xobj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator* pobj;
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator xobj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator* pobj;
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator xobj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->resize((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->resize((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCTrack*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reference obj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_reference obj = ((const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCTrack*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCTrack*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >(*(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >(*(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >& obj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrack& obj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCTrack& obj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->push_back(*(RAT::DS::MCTrack*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator* pobj;
         vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator xobj = ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCTrack*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCTrack*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_837_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > G__TvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR;
static int G__RAT_Dict_837_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) (soff+(sizeof(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >)*i)))->~G__TvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > */
static int G__RAT_Dict_841_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reference obj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->at((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_reference obj = ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->at((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator* pobj;
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator xobj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator* pobj;
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator xobj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator xobj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator* pobj;
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator xobj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->resize((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCPMT*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reference obj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_reference obj = ((const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPMT*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCPMT*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >(*(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >(*(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >& obj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPMT& obj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCPMT& obj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->push_back(*(RAT::DS::MCPMT*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator* pobj;
         vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator xobj = ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCPMT*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCPMT*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_841_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > G__TvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR;
static int G__RAT_Dict_841_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) (soff+(sizeof(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >)*i)))->~G__TvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::MCEV */
static int G__RAT_Dict_844_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCEV* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCEV[n];
     } else {
       p = new((void*) gvp) RAT::DS::MCEV[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::MCEV;
     } else {
       p = new((void*) gvp) RAT::DS::MCEV;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHits& obj = ((RAT::DS::MCEV*) G__getstructoffset())->GetMCHits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHits& obj = ((const RAT::DS::MCEV*) G__getstructoffset())->GetMCHits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCEV*) G__getstructoffset())->SetGTID((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCEV*) G__getstructoffset())->GetGTID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::MCEV*) G__getstructoffset())->GetFullTrigType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCEV*) G__getstructoffset())->SetFullTrigType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCEV*) G__getstructoffset())->SetGTTime((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DS::MCEV*) G__getstructoffset())->GetGTTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::MCEV::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCEV::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::MCEV::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::MCEV::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::MCEV*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCEV::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCEV::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::MCEV::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_844_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::MCEV::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_844_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::MCEV* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::MCEV(*(RAT::DS::MCEV*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::MCEV G__TRATcLcLDScLcLMCEV;
static int G__RAT_Dict_844_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::MCEV*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::MCEV*) (soff+(sizeof(RAT::DS::MCEV)*i)))->~G__TRATcLcLDScLcLMCEV();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::MCEV*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::MCEV*) (soff))->~G__TRATcLcLDScLcLMCEV();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_844_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::MCEV* dest = (RAT::DS::MCEV*) G__getstructoffset();
   *dest = *(RAT::DS::MCEV*) libp->para[0].ref;
   const RAT::DS::MCEV& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::Entry */
static int G__RAT_Dict_845_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Entry* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Entry[n];
     } else {
       p = new((void*) gvp) RAT::DS::Entry[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::Entry;
     } else {
       p = new((void*) gvp) RAT::DS::Entry;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->SetRunID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Entry*) G__getstructoffset())->GetRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->SetSubRunID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::Entry*) G__getstructoffset())->GetSubRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->SetSeed((const Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) ((const RAT::DS::Entry*) G__getstructoffset())->GetSeed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->SetMC(*(RAT::DS::MC*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Entry*) G__getstructoffset())->MCExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MC& obj = ((RAT::DS::Entry*) G__getstructoffset())->GetMC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MC& obj = ((const RAT::DS::Entry*) G__getstructoffset())->GetMC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->PruneMC();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCHits* pobj;
         const RAT::DS::MCHits xobj = ((const RAT::DS::Entry*) G__getstructoffset())->GetAllMCHits();
         pobj = new RAT::DS::MCHits(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->AddMCEV(*(RAT::DS::MCEV*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::Entry*) G__getstructoffset())->GetMCEVCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCEV& obj = ((RAT::DS::Entry*) G__getstructoffset())->GetMCEV((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCEV& obj = ((const RAT::DS::Entry*) G__getstructoffset())->GetMCEV((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->PruneMCEVs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->AddEV(*(RAT::DS::EV*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DS::Entry*) G__getstructoffset())->GetEVCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::EV& obj = ((RAT::DS::Entry*) G__getstructoffset())->GetEV((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::EV& obj = ((const RAT::DS::Entry*) G__getstructoffset())->GetEV((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->PruneEVs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->SetHeaderInfo(*(RAT::DS::HeaderInfo*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::Entry*) G__getstructoffset())->HeaderInfoExists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::HeaderInfo& obj = ((RAT::DS::Entry*) G__getstructoffset())->GetHeaderInfo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::HeaderInfo& obj = ((const RAT::DS::Entry*) G__getstructoffset())->GetHeaderInfo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->PruneHeaderInfos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Calib& obj = ((RAT::DS::Entry*) G__getstructoffset())->GetCalib();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Calib& obj = ((const RAT::DS::Entry*) G__getstructoffset())->GetCalib();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::Entry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Entry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::Entry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::Entry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::Entry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Entry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Entry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::Entry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_845_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::Entry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_845_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::Entry* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::Entry(*(RAT::DS::Entry*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::Entry G__TRATcLcLDScLcLEntry;
static int G__RAT_Dict_845_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::Entry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::Entry*) (soff+(sizeof(RAT::DS::Entry)*i)))->~G__TRATcLcLDScLcLEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::Entry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::Entry*) (soff))->~G__TRATcLcLDScLcLEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_845_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::Entry* dest = (RAT::DS::Entry*) G__getstructoffset();
   *dest = *(RAT::DS::Entry*) libp->para[0].ref;
   const RAT::DS::Entry& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MC,allocator<RAT::DS::MC> > */
static int G__RAT_Dict_847_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reference obj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->at((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_reference obj = ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->at((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator* pobj;
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator xobj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator* pobj;
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator xobj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator* pobj;
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator xobj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator* pobj;
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator xobj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->resize((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->resize((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]), *((RAT::DS::MC*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reference obj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_reference obj = ((const vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MC,allocator<RAT::DS::MC> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MC,allocator<RAT::DS::MC> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]), *(RAT::DS::MC*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]), *(RAT::DS::MC*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MC,allocator<RAT::DS::MC> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >(*(vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >(*(vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MC,allocator<RAT::DS::MC> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MC,allocator<RAT::DS::MC> >(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MC,allocator<RAT::DS::MC> >& obj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->reserve((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MC& obj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MC& obj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->push_back(*(RAT::DS::MC*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator* pobj;
         vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator xobj = ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MC*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MC*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_847_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MC,allocator<RAT::DS::MC> > G__TvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR;
static int G__RAT_Dict_847_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) (soff+(sizeof(vector<RAT::DS::MC,allocator<RAT::DS::MC> >)*i)))->~G__TvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MC,allocator<RAT::DS::MC> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > */
static int G__RAT_Dict_851_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reference obj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->at((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_reference obj = ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->at((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator* pobj;
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator xobj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator* pobj;
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator xobj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator* pobj;
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator xobj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator* pobj;
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator xobj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->resize((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->resize((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]), *((RAT::DS::MCEV*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reference obj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_reference obj = ((const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->operator[]((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCEV*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]), *(RAT::DS::MCEV*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >(*(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >(*(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >& obj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->reserve((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCEV& obj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::MCEV& obj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->push_back(*(RAT::DS::MCEV*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->swap(*(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator* pobj;
         vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator xobj = ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[0])), *(RAT::DS::MCEV*) libp->para[1].ref);
         pobj = new vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type) G__int(libp->para[1])
, *(RAT::DS::MCEV*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->erase(*((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_851_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > G__TvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR;
static int G__RAT_Dict_851_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) (soff+(sizeof(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >)*i)))->~G__TvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*) (soff))->~G__TvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::EV,allocator<RAT::DS::EV> > */
static int G__RAT_Dict_855_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reference obj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->at((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_reference obj = ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->at((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator* pobj;
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator xobj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator* pobj;
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator xobj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator* pobj;
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator xobj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator* pobj;
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator xobj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->resize((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->resize((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]), *((RAT::DS::EV*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reference obj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->operator[]((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_reference obj = ((const vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->operator[]((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::EV,allocator<RAT::DS::EV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::EV,allocator<RAT::DS::EV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]), *(RAT::DS::EV*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]), *(RAT::DS::EV*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::EV,allocator<RAT::DS::EV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >(*(vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >(*(vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::EV,allocator<RAT::DS::EV> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::EV,allocator<RAT::DS::EV> >(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::EV,allocator<RAT::DS::EV> >& obj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->reserve((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::EV& obj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::EV& obj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->push_back(*(RAT::DS::EV*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->swap(*(vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator* pobj;
         vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator xobj = ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[0])), *(RAT::DS::EV*) libp->para[1].ref);
         pobj = new vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->insert(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type) G__int(libp->para[1])
, *(RAT::DS::EV*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->erase(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->erase(*((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_855_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::EV,allocator<RAT::DS::EV> > G__TvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR;
static int G__RAT_Dict_855_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) (soff+(sizeof(vector<RAT::DS::EV,allocator<RAT::DS::EV> >)*i)))->~G__TvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::EV,allocator<RAT::DS::EV> >*) (soff))->~G__TvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > */
static int G__RAT_Dict_859_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reference obj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->at((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_reference obj = ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->at((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator* pobj;
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator xobj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator* pobj;
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator xobj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator* pobj;
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator xobj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator* pobj;
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator xobj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->resize((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->resize((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]), *((RAT::DS::HeaderInfo*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reference obj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->operator[]((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_reference obj = ((const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->operator[]((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >;
     } else {
       p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]), *(RAT::DS::HeaderInfo*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]), *(RAT::DS::HeaderInfo*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >(*(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >(*(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >& obj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->operator=(*(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->reserve((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::HeaderInfo& obj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::HeaderInfo& obj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->push_back(*(RAT::DS::HeaderInfo*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->swap(*(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator* pobj;
         vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator xobj = ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->insert(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[0])), *(RAT::DS::HeaderInfo*) libp->para[1].ref);
         pobj = new vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->insert(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->insert(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[0])), (vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type) G__int(libp->para[1])
, *(RAT::DS::HeaderInfo*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->erase(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->erase(*((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_859_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > G__TvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR;
static int G__RAT_Dict_859_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) (soff+(sizeof(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >)*i)))->~G__TvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*) (soff))->~G__TvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::SOCPMT */
static int G__RAT_Dict_862_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::SOCPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::SOCPMT[n];
     } else {
       p = new((void*) gvp) RAT::DS::SOCPMT[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::SOCPMT;
     } else {
       p = new((void*) gvp) RAT::DS::SOCPMT;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::SOCPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DS::SOCPMT((UInt_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::DS::SOCPMT((UInt_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetLCN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->AddTime((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>* pobj;
         const vector<Float_t> xobj = ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetTimes();
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->AddQHL((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>* pobj;
         const vector<Float_t> xobj = ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetQHLs();
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->AddQHS((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>* pobj;
         const vector<Float_t> xobj = ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetQHSs();
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetTOFManipulator((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetTOFManipulator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetPromptOccupancy((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetPromptOccupancy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetShadowRelativeOccupancy((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetShadowRelativeOccupancy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetRopeShadowRelativeOccupancy((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetRopeShadowRelativeOccupancy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetTimeCentroid((const Float_t) G__double(libp->para[0]), (const Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetTimeCentroid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetTimeCentroidError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->SetPeakFindOK((const RAT::DS::SOCPMT::EPeakFindStatus) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DS::SOCPMT*) G__getstructoffset())->GetPeakFindOK());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->Merge(*(RAT::DS::SOCPMT*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::SOCPMT::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOCPMT::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::SOCPMT::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::SOCPMT::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOCPMT*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOCPMT::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::SOCPMT::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOCPMT::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_862_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::SOCPMT::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_862_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::SOCPMT* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::SOCPMT(*(RAT::DS::SOCPMT*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::SOCPMT G__TRATcLcLDScLcLSOCPMT;
static int G__RAT_Dict_862_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::SOCPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::SOCPMT*) (soff+(sizeof(RAT::DS::SOCPMT)*i)))->~G__TRATcLcLDScLcLSOCPMT();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::SOCPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::SOCPMT*) (soff))->~G__TRATcLcLDScLcLSOCPMT();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_862_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::SOCPMT* dest = (RAT::DS::SOCPMT*) G__getstructoffset();
   *dest = *(RAT::DS::SOCPMT*) libp->para[0].ref;
   const RAT::DS::SOCPMT& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DS::SOC */
static int G__RAT_Dict_864_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::SOC* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::SOC[n];
     } else {
       p = new((void*) gvp) RAT::DS::SOC[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DS::SOC;
     } else {
       p = new((void*) gvp) RAT::DS::SOC;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOCPMT& obj = ((RAT::DS::SOC*) G__getstructoffset())->GetSOCPMT((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOCPMT& obj = ((const RAT::DS::SOC*) G__getstructoffset())->GetSOCPMT((const UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<UInt_t>* pobj;
         const vector<UInt_t> xobj = ((const RAT::DS::SOC*) G__getstructoffset())->GetSOCPMTIDs();
         pobj = new vector<UInt_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DS::SOC*) G__getstructoffset())->SOCPMTExists((const UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->AddSOCPMT(*(RAT::DS::SOCPMT*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->PruneSOCPMTs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->SetSourceID(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DS::SOC*) G__getstructoffset())->GetSourceID();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->SetRunID((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DS::SOC*) G__getstructoffset())->GetRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->SetGlobalTimeOffset((const Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOC*) G__getstructoffset())->GetGlobalTimeOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->SetNPulsesTriggered((const UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const RAT::DS::SOC*) G__getstructoffset())->GetNPulsesTriggered());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DS::SOC*) G__getstructoffset())->GetFitNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::FitResult& obj = ((const RAT::DS::SOC*) G__getstructoffset())->GetFitResult(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->SetFitResult(*(string*) libp->para[0].ref, *(RAT::DS::FitResult*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Calib& obj = ((RAT::DS::SOC*) G__getstructoffset())->GetCalib();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Calib& obj = ((const RAT::DS::SOC*) G__getstructoffset())->GetCalib();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->Merge(*(RAT::DS::SOC*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DS::SOC::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOC::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DS::SOC::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DS::SOC::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DS::SOC*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOC::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::SOC::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DS::SOC::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_864_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DS::SOC::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_864_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DS::SOC* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DS::SOC(*(RAT::DS::SOC*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DS::SOC G__TRATcLcLDScLcLSOC;
static int G__RAT_Dict_864_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DS::SOC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DS::SOC*) (soff+(sizeof(RAT::DS::SOC)*i)))->~G__TRATcLcLDScLcLSOC();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DS::SOC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DS::SOC*) (soff))->~G__TRATcLcLDScLcLSOC();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_864_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DS::SOC* dest = (RAT::DS::SOC*) G__getstructoffset();
   *dest = *(RAT::DS::SOC*) libp->para[0].ref;
   const RAT::DS::SOC& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > */
static int G__RAT_Dict_867_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >[n];
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >;
     } else {
       p = new((void*) gvp) map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >(*(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >& obj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->operator=(*(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->begin();
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->end();
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->rbegin();
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->rend();
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOCPMT& obj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->operator[](*(unsigned int*) G__UIntref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator,bool>* pobj;
         pair<map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator,bool> xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->insert(*(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])), *(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::value_type*) libp->para[1].ref);
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->insert(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->erase(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->erase(*((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[0])), *((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->swap(*(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->find(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->count(*(unsigned int*) G__UIntref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->lower_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_867_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator* pobj;
         map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator xobj = ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) G__getstructoffset())->upper_bound(*(unsigned int*) G__UIntref(&libp->para[0]));
         pobj = new map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > G__TmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR;
static int G__RAT_Dict_867_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) (soff+(sizeof(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >)*i)))->~G__TmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*) (soff))->~G__TmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* pair<unsigned int,RAT::DS::SOCPMT> */
static int G__RAT_Dict_868_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::SOCPMT>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::SOCPMT>[n];
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::SOCPMT>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new pair<unsigned int,RAT::DS::SOCPMT>;
     } else {
       p = new((void*) gvp) pair<unsigned int,RAT::DS::SOCPMT>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_868_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pair<unsigned int,RAT::DS::SOCPMT>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pair<unsigned int,RAT::DS::SOCPMT>(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::SOCPMT*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) pair<unsigned int,RAT::DS::SOCPMT>(*(unsigned int*) G__UIntref(&libp->para[0]), *(RAT::DS::SOCPMT*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_868_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pair<unsigned int,RAT::DS::SOCPMT>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pair<unsigned int,RAT::DS::SOCPMT>(*(pair<unsigned int,RAT::DS::SOCPMT>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pair<unsigned int,RAT::DS::SOCPMT> G__TpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR;
static int G__RAT_Dict_868_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pair<unsigned int,RAT::DS::SOCPMT>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pair<unsigned int,RAT::DS::SOCPMT>*) (soff+(sizeof(pair<unsigned int,RAT::DS::SOCPMT>)*i)))->~G__TpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pair<unsigned int,RAT::DS::SOCPMT>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pair<unsigned int,RAT::DS::SOCPMT>*) (soff))->~G__TpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::DataCleaningBits */
static int G__RAT_Dict_879_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataCleaningBits*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DU::DataCleaningBits*) G__getstructoffset())->GetBitName((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::DataCleaningBits*) G__getstructoffset())->GetBitIndex(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetMapBegin();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetMapLast();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetMapEnd();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetInverseMapBegin();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetInverseMapLast();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataCleaningBits*) G__getstructoffset())->GetInverseMapEnd();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataCleaningBits*) G__getstructoffset())->DumpNames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::DataCleaningBits::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataCleaningBits::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::DataCleaningBits::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::DataCleaningBits::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataCleaningBits*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataCleaningBits::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DataCleaningBits::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataCleaningBits::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_879_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DataCleaningBits::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_879_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DataCleaningBits *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DataCleaningBits[n];
     } else {
       p = new((void*) gvp) RAT::DU::DataCleaningBits[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DataCleaningBits;
     } else {
       p = new((void*) gvp) RAT::DU::DataCleaningBits;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_879_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::DataCleaningBits* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::DataCleaningBits(*(RAT::DU::DataCleaningBits*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::DataCleaningBits G__TRATcLcLDUcLcLDataCleaningBits;
static int G__RAT_Dict_879_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::DataCleaningBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::DataCleaningBits*) (soff+(sizeof(RAT::DU::DataCleaningBits)*i)))->~G__TRATcLcLDUcLcLDataCleaningBits();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::DataCleaningBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::DataCleaningBits*) (soff))->~G__TRATcLcLDUcLcLDataCleaningBits();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_879_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DataCleaningBits* dest = (RAT::DU::DataCleaningBits*) G__getstructoffset();
   *dest = *(RAT::DU::DataCleaningBits*) libp->para[0].ref;
   const RAT::DU::DataCleaningBits& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::DataQualityBits */
static int G__RAT_Dict_895_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataQualityBits*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DU::DataQualityBits*) G__getstructoffset())->GetBitName((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::DataQualityBits*) G__getstructoffset())->GetBitIndex(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetMapBegin();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetMapLast();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator* pobj;
         map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetMapEnd();
         pobj = new map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetInverseMapBegin();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetInverseMapLast();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator* pobj;
         map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator xobj = ((RAT::DU::DataQualityBits*) G__getstructoffset())->GetInverseMapEnd();
         pobj = new map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataQualityBits*) G__getstructoffset())->DumpNames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::DataQualityBits::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataQualityBits::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::DataQualityBits::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::DataQualityBits::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DataQualityBits*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataQualityBits::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DataQualityBits::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DataQualityBits::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_895_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DataQualityBits::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_895_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DataQualityBits *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DataQualityBits[n];
     } else {
       p = new((void*) gvp) RAT::DU::DataQualityBits[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DataQualityBits;
     } else {
       p = new((void*) gvp) RAT::DU::DataQualityBits;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_895_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::DataQualityBits* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::DataQualityBits(*(RAT::DU::DataQualityBits*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::DataQualityBits G__TRATcLcLDUcLcLDataQualityBits;
static int G__RAT_Dict_895_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::DataQualityBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::DataQualityBits*) (soff+(sizeof(RAT::DU::DataQualityBits)*i)))->~G__TRATcLcLDUcLcLDataQualityBits();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::DataQualityBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::DataQualityBits*) (soff))->~G__TRATcLcLDUcLcLDataQualityBits();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_895_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DataQualityBits* dest = (RAT::DU::DataQualityBits*) G__getstructoffset();
   *dest = *(RAT::DU::DataQualityBits*) libp->para[0].ref;
   const RAT::DU::DataQualityBits& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ChanSWStatus */
static int G__RAT_Dict_897_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ChanSWStatus* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ChanSWStatus[n];
     } else {
       p = new((void*) gvp) RAT::DU::ChanSWStatus[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ChanSWStatus;
     } else {
       p = new((void*) gvp) RAT::DU::ChanSWStatus;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ChanSWStatus*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->IsTubeStable((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->GetBitName((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->GetBitIndex(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ChanSWStatus*) G__getstructoffset())->DumpNames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->GetBitNames();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<std::string,size_t>& obj = ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->GetBitMap();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<size_t,std::string>& obj = ((const RAT::DU::ChanSWStatus*) G__getstructoffset())->GetInverseBitMap();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::ChanSWStatus::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanSWStatus::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::ChanSWStatus::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::ChanSWStatus::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ChanSWStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanSWStatus::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::ChanSWStatus::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanSWStatus::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_897_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::ChanSWStatus::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_897_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ChanSWStatus* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ChanSWStatus(*(RAT::DU::ChanSWStatus*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ChanSWStatus G__TRATcLcLDUcLcLChanSWStatus;
static int G__RAT_Dict_897_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ChanSWStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ChanSWStatus*) (soff+(sizeof(RAT::DU::ChanSWStatus)*i)))->~G__TRATcLcLDUcLcLChanSWStatus();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ChanSWStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ChanSWStatus*) (soff))->~G__TRATcLcLDUcLcLChanSWStatus();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_897_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ChanSWStatus* dest = (RAT::DU::ChanSWStatus*) G__getstructoffset();
   *dest = *(RAT::DU::ChanSWStatus*) libp->para[0].ref;
   const RAT::DU::ChanSWStatus& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::TrigBits */
static int G__RAT_Dict_899_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::TrigBits::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::DU::TrigBits::GetBitName((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) RAT::DU::TrigBits::GetBitIndex(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) RAT::DU::TrigBits::GetMask(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::TrigBits::DumpNames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::TrigBits::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TrigBits::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::TrigBits::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::TrigBits::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::TrigBits*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TrigBits::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::TrigBits::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TrigBits::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_899_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::TrigBits::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_899_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::TrigBits *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::TrigBits[n];
     } else {
       p = new((void*) gvp) RAT::DU::TrigBits[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::TrigBits;
     } else {
       p = new((void*) gvp) RAT::DU::TrigBits;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_899_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::TrigBits* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::TrigBits(*(RAT::DU::TrigBits*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::TrigBits G__TRATcLcLDUcLcLTrigBits;
static int G__RAT_Dict_899_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::TrigBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::TrigBits*) (soff+(sizeof(RAT::DU::TrigBits)*i)))->~G__TRATcLcLDUcLcLTrigBits();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::TrigBits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::TrigBits*) (soff))->~G__TRATcLcLDUcLcLTrigBits();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_899_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::TrigBits* dest = (RAT::DU::TrigBits*) G__getstructoffset();
   *dest = *(RAT::DU::TrigBits*) libp->para[0].ref;
   const RAT::DU::TrigBits& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::DSReader */
static int G__RAT_Dict_975_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DSReader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DSReader(*(string*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::DU::DSReader(*(string*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DSReader(*(string*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::DU::DSReader(*(string*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DSReader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DSReader(*(vector<std::string>*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::DU::DSReader(*(vector<std::string>*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::DSReader(*(vector<std::string>*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::DU::DSReader(*(vector<std::string>*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DSReader*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DSReader*) G__getstructoffset())->Add(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Entry& obj = ((RAT::DU::DSReader*) G__getstructoffset())->GetEntry((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::DSReader*) G__getstructoffset())->GetEntryCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::DSReader*) G__getstructoffset())->GetRun();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::DSReader*) G__getstructoffset())->GetRunByRunID((const unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::DSReader*) G__getstructoffset())->GetRunByIndex((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::DSReader*) G__getstructoffset())->GetRunCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Meta& obj = ((const RAT::DU::DSReader*) G__getstructoffset())->GetMeta();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::DSReader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DSReader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::DSReader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::DSReader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::DSReader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DSReader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DSReader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::DSReader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_975_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::DSReader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_975_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::DSReader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::DSReader(*(RAT::DU::DSReader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::DSReader G__TRATcLcLDUcLcLDSReader;
static int G__RAT_Dict_975_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::DSReader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::DSReader*) (soff+(sizeof(RAT::DU::DSReader)*i)))->~G__TRATcLcLDUcLcLDSReader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::DSReader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::DSReader*) (soff))->~G__TRATcLcLDUcLcLDSReader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_975_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::DSReader* dest = (RAT::DU::DSReader*) G__getstructoffset();
   *dest = *(RAT::DU::DSReader*) libp->para[0].ref;
   const RAT::DU::DSReader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::EffectiveVelocity */
static int G__RAT_Dict_976_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::EffectiveVelocity*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EffectiveVelocity*) G__getstructoffset())->CalcByDistance((const double) G__double(libp->para[0]), (const double) G__double(libp->para[1])
, (const double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EffectiveVelocity*) G__getstructoffset())->GetInnerAVVelocity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EffectiveVelocity*) G__getstructoffset())->GetAVVelocity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EffectiveVelocity*) G__getstructoffset())->GetWaterVelocity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EffectiveVelocity*) G__getstructoffset())->GetOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::EffectiveVelocity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EffectiveVelocity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::EffectiveVelocity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::EffectiveVelocity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::EffectiveVelocity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EffectiveVelocity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::EffectiveVelocity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EffectiveVelocity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_976_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::EffectiveVelocity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_976_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::EffectiveVelocity *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::EffectiveVelocity[n];
     } else {
       p = new((void*) gvp) RAT::DU::EffectiveVelocity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::EffectiveVelocity;
     } else {
       p = new((void*) gvp) RAT::DU::EffectiveVelocity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_976_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::EffectiveVelocity* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::EffectiveVelocity(*(RAT::DU::EffectiveVelocity*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::EffectiveVelocity G__TRATcLcLDUcLcLEffectiveVelocity;
static int G__RAT_Dict_976_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::EffectiveVelocity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::EffectiveVelocity*) (soff+(sizeof(RAT::DU::EffectiveVelocity)*i)))->~G__TRATcLcLDUcLcLEffectiveVelocity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::EffectiveVelocity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::EffectiveVelocity*) (soff))->~G__TRATcLcLDUcLcLEffectiveVelocity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_976_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::EffectiveVelocity* dest = (RAT::DU::EffectiveVelocity*) G__getstructoffset();
   *dest = *(RAT::DU::EffectiveVelocity*) libp->para[0].ref;
   const RAT::DU::EffectiveVelocity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DBTable */
static int G__RAT_Dict_1029_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable[n];
     } else {
       p = new((void*) gvp) RAT::DBTable[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable;
     } else {
       p = new((void*) gvp) RAT::DBTable;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) RAT::DBTable(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1])));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable(*((string*) G__int(libp->para[0])));
     } else {
       p = new((void*) gvp) RAT::DBTable(*((string*) G__int(libp->para[0])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable(*(json::Value*) libp->para[0].ref, (const size_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::DBTable(*(json::Value*) libp->para[0].ref, (const size_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTable(*(json::Value*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::DBTable(*(json::Value*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RAT::DBTable*) G__getstructoffset())->SaveAs(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DBTable*) G__getstructoffset())->GetName();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetName(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DBTable*) G__getstructoffset())->GetIndex();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetIndex(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->GetRunBegin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->GetRunEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->GetPassNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DBTable*) G__getstructoffset())->IsUser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DBTable*) G__getstructoffset())->IsDefault());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DBTable*) G__getstructoffset())->IsValidRun((const int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetRunRange((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetPassNumber((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetUser();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetDefault();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->GetFieldType(*((string*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DBTable*) G__getstructoffset())->GetFieldList();
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->GetI(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DBTable*) G__getstructoffset())->GetD(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DBTable*) G__getstructoffset())->GetS(*(string*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DBTable*) G__getstructoffset())->GetZ(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<int>* pobj;
         const vector<int> xobj = ((const RAT::DBTable*) G__getstructoffset())->GetIArray(*(string*) libp->para[0].ref);
         pobj = new vector<int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const RAT::DBTable*) G__getstructoffset())->GetDArray(*(string*) libp->para[0].ref);
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::string>* pobj;
         const vector<std::string> xobj = ((const RAT::DBTable*) G__getstructoffset())->GetSArray(*(string*) libp->para[0].ref);
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool>* pobj;
         const vector<bool> xobj = ((const RAT::DBTable*) G__getstructoffset())->GetZArray(*(string*) libp->para[0].ref);
         pobj = new vector<bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value* pobj;
         const json::Value xobj = ((const RAT::DBTable*) G__getstructoffset())->GetJSON(*(string*) libp->para[0].ref);
         pobj = new json::Value(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetI(*((string*) G__int(libp->para[0])), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetD(*((string*) G__int(libp->para[0])), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetS(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetZ(*((string*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetIArray(*((string*) G__int(libp->para[0])), *(vector<int>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetDArray(*((string*) G__int(libp->para[0])), *(vector<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetSArray(*((string*) G__int(libp->para[0])), *(vector<std::string>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetZArray(*((string*) G__int(libp->para[0])), *(vector<bool>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBTable*) G__getstructoffset())->SetJSON(*(string*) libp->para[0].ref, *(json::Value*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DBTable*) G__getstructoffset())->GetBytes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const json::Value& obj = ((RAT::DBTable*) G__getstructoffset())->GetRawJSONTable();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DBTable*) G__getstructoffset())->Get<int>(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DBTable*) G__getstructoffset())->Get<double>(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1029_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DBTable*) G__getstructoffset())->Get<bool>(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1029_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DBTable* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DBTable(*(RAT::DBTable*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DBTable G__TRATcLcLDBTable;
static int G__RAT_Dict_1029_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DBTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DBTable*) (soff+(sizeof(RAT::DBTable)*i)))->~G__TRATcLcLDBTable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DBTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DBTable*) (soff))->~G__TRATcLcLDBTable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1029_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTable* dest = (RAT::DBTable*) G__getstructoffset();
   *dest = *(RAT::DBTable*) libp->para[0].ref;
   const RAT::DBTable& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DB */
static int G__RAT_Dict_1043_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DB::Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::DB::ParseTableName(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::DB::ParseFieldName(*((string*) G__int(libp->para[0])), *(string*) libp->para[1].ref
, *(int*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*>* pobj;
         vector<RAT::DBTable*> xobj = RAT::DB::ReadRATDBFile(*(string*) libp->para[0].ref);
         pobj = new vector<RAT::DBTable*>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBTableKey* pobj;
         RAT::DBTableKey xobj = RAT::DB::GetTableKey((RAT::DBTable*) G__int(libp->para[0]));
         pobj = new RAT::DBTableKey(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DB::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DB::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DB::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DB::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::DB*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DB::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DB::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DB::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DB::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DB* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DB[n];
     } else {
       p = new((void*) gvp) RAT::DB[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DB;
     } else {
       p = new((void*) gvp) RAT::DB;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->InitBackend();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::DB*) G__getstructoffset())->RefreshTablesOnServer((const unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::DB*) G__getstructoffset())->RefreshTablesOnServer();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->BeginOfRun(*(RAT::DS::Run*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->EndOfBeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->EndOfRun(*(RAT::DS::Run*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->CheckSetFieldUsage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->CheckLoadedTables(*(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->Load(*((const string*) G__int(libp->para[0])), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->Load(*((const string*) G__int(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->LoadFile(*((const string*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->LoadAll(*((const string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))));
      break;
   case 1:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->LoadAll(*((const string*) G__int(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->LoadDefaults());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->AllowDanger();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->LoadDefaultPlaneLocks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RAT::DB*) G__getstructoffset())->SetServer(*(string*) libp->para[0].ref, (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::DB*) G__getstructoffset())->SetServer(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         RAT::DBLinkPtr* pobj;
         RAT::DBLinkPtr xobj = ((RAT::DB*) G__getstructoffset())->GetLink(*((const string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (int) G__int(libp->para[2]));
         pobj = new RAT::DBLinkPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         RAT::DBLinkPtr* pobj;
         RAT::DBLinkPtr xobj = ((RAT::DB*) G__getstructoffset())->GetLink(*((const string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1])));
         pobj = new RAT::DBLinkPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         RAT::DBLinkPtr* pobj;
         RAT::DBLinkPtr xobj = ((RAT::DB*) G__getstructoffset())->GetLink(*((const string*) G__int(libp->para[0])));
         pobj = new RAT::DBLinkPtr(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBLinkGroup* pobj;
         RAT::DBLinkGroup xobj = ((RAT::DB*) G__getstructoffset())->GetLinkGroup(*((const string*) G__int(libp->para[0])));
         pobj = new RAT::DBLinkGroup(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->AddTblNoDefaultPlane(*((string*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->RemoveTblNoDefaultPlane(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDefaultPlaneLockStatus((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<std::pair<std::string,std::string> >* pobj;
         vector<std::pair<std::string,std::string> > xobj = ((RAT::DB*) G__getstructoffset())->GetTblNoDefaultPlane();
         pobj = new vector<std::pair<std::string,std::string> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->GetTblNoDefaultPlaneStatus(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->GetTblNoDefaultPlaneStatus(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->UploadTableOnline(*(RAT::DBTable*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDbTag(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const RAT::DB*) G__getstructoffset())->GetDBTag();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->IsValidField(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->IsValidFieldType(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetI(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (int) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetI(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (int) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetD(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetD(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetS(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetS(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), *((string*) G__int(libp->para[3])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZ(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZ(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (bool) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetIArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *(vector<int>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetIArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), *(vector<int>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetIValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (size_t) G__int(libp->para[2]), (int) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetIValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (size_t) G__int(libp->para[3])
, (int) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *(vector<double>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), *(vector<double>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (size_t) G__int(libp->para[2]), (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetDValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (size_t) G__int(libp->para[3])
, (double) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetSArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *(vector<std::string>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetSArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), *(vector<std::string>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetSValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (size_t) G__int(libp->para[2]), *((string*) G__int(libp->para[3])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetSValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (size_t) G__int(libp->para[3])
, *((string*) G__int(libp->para[4])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *(vector<bool>*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), *(vector<bool>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, (size_t) G__int(libp->para[2]), (bool) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetZValInArray(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (size_t) G__int(libp->para[3])
, (bool) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::DB*) G__getstructoffset())->GetUserTable(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((RAT::DB*) G__getstructoffset())->GetRunTable(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((RAT::DB*) G__getstructoffset())->GetRunTable(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))
, (int) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::DB*) G__getstructoffset())->GetDefaultTable(*((const string*) G__int(libp->para[0])), *((const string*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->RemoveLink((RAT::DBLink*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->NumLinks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<double>* pobj;
         vector<double> xobj = RAT::DB::FloatToDoubleArray(*(vector<float>*) libp->para[0].ref);
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetRunID((const unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((RAT::DB*) G__getstructoffset())->GetRunID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DB*) G__getstructoffset())->SetPassDBEntry(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (int) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->GetPassDBEntry(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1]))));
      break;
   case 1:
      G__letint(result7, 105, (long) ((RAT::DB*) G__getstructoffset())->GetPassDBEntry(*((string*) G__int(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::DB*) G__getstructoffset())->SetAirplaneModeStatus((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::DB*) G__getstructoffset())->SetAirplaneModeStatus();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->GetAirplaneModeStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1043_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DB*) G__getstructoffset())->AreDefaultsLoaded());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1043_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DB* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DB(*(RAT::DB*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DB G__TRATcLcLDB;
static int G__RAT_Dict_1043_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DB*) (soff+(sizeof(RAT::DB)*i)))->~G__TRATcLcLDB();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DB*) (soff))->~G__TRATcLcLDB();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1043_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DB* dest = (RAT::DB*) G__getstructoffset();
   *dest = *(RAT::DB*) libp->para[0].ref;
   const RAT::DB& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DBLink */
static int G__RAT_Dict_1044_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBLink* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBLink(
(RAT::DB*) G__int(libp->para[0]), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RAT::DBLink(
(RAT::DB*) G__int(libp->para[0]), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBLink(
(RAT::DB*) G__int(libp->para[0]), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])));
     } else {
       p = new((void*) gvp) RAT::DBLink(
(RAT::DB*) G__int(libp->para[0]), *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DBLink*) G__getstructoffset())->GetName();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::DBLink*) G__getstructoffset())->GetIndex();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBLink*) G__getstructoffset())->SetCurrentRun((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RAT::DBLink*) G__getstructoffset())->GetI(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DBLink*) G__getstructoffset())->GetD(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = ((RAT::DBLink*) G__getstructoffset())->GetS(*(string*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DBLink*) G__getstructoffset())->GetZ(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int>* pobj;
         vector<int> xobj = ((RAT::DBLink*) G__getstructoffset())->GetIArray(*(string*) libp->para[0].ref);
         pobj = new vector<int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<float>* pobj;
         vector<float> xobj = ((RAT::DBLink*) G__getstructoffset())->GetFArrayFromD(*(string*) libp->para[0].ref);
         pobj = new vector<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<float>* pobj;
         vector<float> xobj = ((RAT::DBLink*) G__getstructoffset())->DArrayToFArray(*(vector<double>*) libp->para[0].ref);
         pobj = new vector<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<double>* pobj;
         vector<double> xobj = ((RAT::DBLink*) G__getstructoffset())->GetDArray(*(string*) libp->para[0].ref);
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<std::string>* pobj;
         vector<std::string> xobj = ((RAT::DBLink*) G__getstructoffset())->GetSArray(*(string*) libp->para[0].ref);
         pobj = new vector<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<bool>* pobj;
         vector<bool> xobj = ((RAT::DBLink*) G__getstructoffset())->GetZArray(*(string*) libp->para[0].ref);
         pobj = new vector<bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         json::Value* pobj;
         json::Value xobj = ((RAT::DBLink*) G__getstructoffset())->GetJSON(*(string*) libp->para[0].ref);
         pobj = new json::Value(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1044_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DBLink*) G__getstructoffset())->Unlink();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1044_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DBLink* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DBLink(*(RAT::DBLink*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DBLink G__TRATcLcLDBLink;
static int G__RAT_Dict_1044_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DBLink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DBLink*) (soff+(sizeof(RAT::DBLink)*i)))->~G__TRATcLcLDBLink();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DBLink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DBLink*) (soff))->~G__TRATcLcLDBLink();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1044_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBLink* dest = (RAT::DBLink*) G__getstructoffset();
   *dest = *(RAT::DBLink*) libp->para[0].ref;
   const RAT::DBLink& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::PgSQLBackend */
static int G__RAT_Dict_1045_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::PgSQLBackend* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::PgSQLBackend(*(string*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::PgSQLBackend(*(string*) libp->para[0].ref);
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RAT::PgSQLBackend[n];
       } else {
         p = new((void*) gvp) RAT::PgSQLBackend[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RAT::PgSQLBackend;
       } else {
         p = new((void*) gvp) RAT::PgSQLBackend;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetConnOpts(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const RAT::PgSQLBackend*) G__getstructoffset())->GetConnOpts();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetConnURL(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const RAT::PgSQLBackend*) G__getstructoffset())->GetConnURL();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->Disconnect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->Connect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->InsertObject(*(RAT::DBTable*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         set<std::string>* pobj;
         set<std::string> xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->GetListIndexes(*(string*) libp->para[0].ref, *(int*) G__Intref(&libp->para[1]));
         pobj = new set<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         set<std::string>* pobj;
         set<std::string> xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->GetListIndexes(*(string*) libp->para[0].ref);
         pobj = new set<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         set<std::string>* pobj;
         set<std::string> xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->GetListTypes((const int) G__int(libp->para[0]));
         pobj = new set<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         set<std::string>* pobj;
         set<std::string> xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->GetListTypes();
         pobj = new set<std::string>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         json::Value* pobj;
         json::Value xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->FetchObjFast(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(bool*) G__Boolref(&libp->para[2]), *(size_t*) G__ULongref(&libp->para[3]));
         pobj = new json::Value(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         json::Value* pobj;
         json::Value xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->FetchObject(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(int*) G__Intref(&libp->para[2]), *(int*) G__Intref(&libp->para[3])
, *(bool*) G__Boolref(&libp->para[4]), *(size_t*) G__ULongref(&libp->para[5]));
         pobj = new json::Value(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetReconnectRetries(*(unsigned int*) G__UIntref(&libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const unsigned int& obj = ((const RAT::PgSQLBackend*) G__getstructoffset())->GetReconnRetries();
         result7->ref = (long) (&obj);
         G__letint(result7, 'h', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetBoRCompleted((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetBoRCompleted();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::PgSQLBackend*) G__getstructoffset())->GetBoRCompleted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::PgSQLBackend*) G__getstructoffset())->SetDbTag(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1045_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = ((RAT::PgSQLBackend*) G__getstructoffset())->GetDbTag();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1045_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::PgSQLBackend* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::PgSQLBackend(*(RAT::PgSQLBackend*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::PgSQLBackend G__TRATcLcLPgSQLBackend;
static int G__RAT_Dict_1045_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::PgSQLBackend*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::PgSQLBackend*) (soff+(sizeof(RAT::PgSQLBackend)*i)))->~G__TRATcLcLPgSQLBackend();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::PgSQLBackend*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::PgSQLBackend*) (soff))->~G__TRATcLcLPgSQLBackend();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1045_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::PgSQLBackend* dest = (RAT::PgSQLBackend*) G__getstructoffset();
   *dest = *(RAT::PgSQLBackend*) libp->para[0].ref;
   const RAT::PgSQLBackend& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* simple_ptr_nocopy<RAT::DBTable> */
static int G__RAT_Dict_1047_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBTable>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new simple_ptr_nocopy<RAT::DBTable>[n];
     } else {
       p = new((void*) gvp) simple_ptr_nocopy<RAT::DBTable>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new simple_ptr_nocopy<RAT::DBTable>;
     } else {
       p = new((void*) gvp) simple_ptr_nocopy<RAT::DBTable>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBTable>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new simple_ptr_nocopy<RAT::DBTable>(*(simple_ptr_nocopy<RAT::DBTable>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) simple_ptr_nocopy<RAT::DBTable>(*(simple_ptr_nocopy<RAT::DBTable>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const simple_ptr_nocopy<RAT::DBTable>& obj = ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator=(*(simple_ptr_nocopy<RAT::DBTable>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBTable>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new simple_ptr_nocopy<RAT::DBTable>((RAT::DBTable*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) simple_ptr_nocopy<RAT::DBTable>((RAT::DBTable*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const simple_ptr_nocopy<RAT::DBTable>& obj = ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator=((RAT::DBTable*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator bool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator!());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->present());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->null());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBTable& obj = ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBTable& obj = ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBTable& obj = ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->value();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBTable& obj = ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->value();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->set((RAT::DBTable*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->set();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->pointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->pointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->aliases(*(simple_ptr_nocopy<RAT::DBTable>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->alias_count());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1047_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((simple_ptr_nocopy<RAT::DBTable>*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef simple_ptr_nocopy<RAT::DBTable> G__Tsimple_ptr_nocopylERATcLcLDBTablegR;
static int G__RAT_Dict_1047_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (simple_ptr_nocopy<RAT::DBTable>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((simple_ptr_nocopy<RAT::DBTable>*) (soff+(sizeof(simple_ptr_nocopy<RAT::DBTable>)*i)))->~G__Tsimple_ptr_nocopylERATcLcLDBTablegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (simple_ptr_nocopy<RAT::DBTable>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((simple_ptr_nocopy<RAT::DBTable>*) (soff))->~G__Tsimple_ptr_nocopylERATcLcLDBTablegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* simple_ptr_nocopy<RAT::DBLink> */
static int G__RAT_Dict_1057_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBLink>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new simple_ptr_nocopy<RAT::DBLink>[n];
     } else {
       p = new((void*) gvp) simple_ptr_nocopy<RAT::DBLink>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new simple_ptr_nocopy<RAT::DBLink>;
     } else {
       p = new((void*) gvp) simple_ptr_nocopy<RAT::DBLink>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBLink>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new simple_ptr_nocopy<RAT::DBLink>(*(simple_ptr_nocopy<RAT::DBLink>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) simple_ptr_nocopy<RAT::DBLink>(*(simple_ptr_nocopy<RAT::DBLink>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const simple_ptr_nocopy<RAT::DBLink>& obj = ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator=(*(simple_ptr_nocopy<RAT::DBLink>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   simple_ptr_nocopy<RAT::DBLink>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new simple_ptr_nocopy<RAT::DBLink>((RAT::DBLink*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) simple_ptr_nocopy<RAT::DBLink>((RAT::DBLink*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const simple_ptr_nocopy<RAT::DBLink>& obj = ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator=((RAT::DBLink*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator bool());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator!());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->present());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->null());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBLink& obj = ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBLink& obj = ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBLink& obj = ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->value();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBLink& obj = ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->value();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->set((RAT::DBLink*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->set();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->pointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->pointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->aliases(*(simple_ptr_nocopy<RAT::DBLink>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->alias_count());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1057_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((simple_ptr_nocopy<RAT::DBLink>*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef simple_ptr_nocopy<RAT::DBLink> G__Tsimple_ptr_nocopylERATcLcLDBLinkgR;
static int G__RAT_Dict_1057_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (simple_ptr_nocopy<RAT::DBLink>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((simple_ptr_nocopy<RAT::DBLink>*) (soff+(sizeof(simple_ptr_nocopy<RAT::DBLink>)*i)))->~G__Tsimple_ptr_nocopylERATcLcLDBLinkgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (simple_ptr_nocopy<RAT::DBLink>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((simple_ptr_nocopy<RAT::DBLink>*) (soff))->~G__Tsimple_ptr_nocopylERATcLcLDBLinkgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DBTable*,allocator<RAT::DBTable*> > */
static int G__RAT_Dict_1066_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reference obj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->at((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_reference obj = ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->at((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator* pobj;
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator xobj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator* pobj;
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator xobj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator* pobj;
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator xobj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator* pobj;
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator xobj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->resize((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->resize((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]), (RAT::DBTable*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reference obj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->operator[]((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_reference obj = ((const vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->operator[]((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable*,allocator<RAT::DBTable*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >;
     } else {
       p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable*,allocator<RAT::DBTable*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(RAT::DBTable**) libp->para[1].ref : *(RAT::DBTable**) (void*) (&G__Mlong(libp->para[1])));
     } else {
       p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(RAT::DBTable**) libp->para[1].ref : *(RAT::DBTable**) (void*) (&G__Mlong(libp->para[1])));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable*,allocator<RAT::DBTable*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >(*(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >(*(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable*,allocator<RAT::DBTable*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DBTable*,allocator<RAT::DBTable*> >(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DBTable*,allocator<RAT::DBTable*> >& obj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->operator=(*(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->reserve((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBTable*& obj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DBTable*& obj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->push_back(libp->para[0].ref ? *(RAT::DBTable**) libp->para[0].ref : *(RAT::DBTable**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->swap(*(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator* pobj;
         vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator xobj = ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[0])), libp->para[1].ref ? *(RAT::DBTable**) libp->para[1].ref : *(RAT::DBTable**) (void*) (&G__Mlong(libp->para[1])));
         pobj = new vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[0])), (vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type) G__int(libp->para[1])
, libp->para[2].ref ? *(RAT::DBTable**) libp->para[2].ref : *(RAT::DBTable**) (void*) (&G__Mlong(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->erase(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->erase(*((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1066_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DBTable*,allocator<RAT::DBTable*> > G__TvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR;
static int G__RAT_Dict_1066_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) (soff+(sizeof(vector<RAT::DBTable*,allocator<RAT::DBTable*> >)*i)))->~G__TvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DBTable*,allocator<RAT::DBTable*> >*) (soff))->~G__TvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::GroupVelocity */
static int G__RAT_Dict_1098_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::GroupVelocity*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::GroupVelocity*) G__getstructoffset())->CalcByDistance((const double) G__double(libp->para[0]), (const double) G__double(libp->para[1])
, (const double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::GroupVelocity*) G__getstructoffset())->CalcByDistance((const double) G__double(libp->para[0]), (const double) G__double(libp->para[1])
, (const double) G__double(libp->para[2]), (const double) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::GroupVelocity*) G__getstructoffset())->PMTBucketTime((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::GroupVelocity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::GroupVelocity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::GroupVelocity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::GroupVelocity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::GroupVelocity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::GroupVelocity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::GroupVelocity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::GroupVelocity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1098_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::GroupVelocity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1098_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::GroupVelocity *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::GroupVelocity[n];
     } else {
       p = new((void*) gvp) RAT::DU::GroupVelocity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::GroupVelocity;
     } else {
       p = new((void*) gvp) RAT::DU::GroupVelocity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1098_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::GroupVelocity* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::GroupVelocity(*(RAT::DU::GroupVelocity*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::GroupVelocity G__TRATcLcLDUcLcLGroupVelocity;
static int G__RAT_Dict_1098_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::GroupVelocity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::GroupVelocity*) (soff+(sizeof(RAT::DU::GroupVelocity)*i)))->~G__TRATcLcLDUcLcLGroupVelocity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::GroupVelocity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::GroupVelocity*) (soff))->~G__TRATcLcLDUcLcLGroupVelocity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1098_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::GroupVelocity* dest = (RAT::DU::GroupVelocity*) G__getstructoffset();
   *dest = *(RAT::DU::GroupVelocity*) libp->para[0].ref;
   const RAT::DU::GroupVelocity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::LightPathCalculator */
static int G__RAT_Dict_1100_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::LightPathCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::LightPathCalculator[n];
     } else {
       p = new((void*) gvp) RAT::DU::LightPathCalculator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::LightPathCalculator;
     } else {
       p = new((void*) gvp) RAT::DU::LightPathCalculator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->LoadRefractiveIndex(*((RAT::DBLinkPtr*) G__int(libp->para[0])), *(TGraph*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->ResetValues();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPosition(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const Double_t) G__double(libp->para[2]), (const Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPosition(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPosition(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPositionPartial(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const Double_t) G__double(libp->para[2]), (const Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPositionPartial(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalcByPositionPartial(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalculateSolidAngle(*(TVector3*) libp->para[0].ref, (const UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalculateCosThetaPMT((const Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalculateFresnelTRCoeff();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalculateParallelTransmissionCoefficient((const Double_t) G__double(libp->para[0]), (const Double_t) G__double(libp->para[1])
, (const Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DU::LightPathCalculator*) G__getstructoffset())->CalculatePerpendicularTransmissionCoefficient((const Double_t) G__double(libp->para[0]), (const Double_t) G__double(libp->para[1])
, (const Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetInnerAVRI((const Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetUpperTargetRI((const Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetLowerTargetRI((const Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetAVRI((const Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetWaterRI((const Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetLoopCeiling());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetFinalLoopValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetTIR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetResvHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPathValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetXAVNeck());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetStraightLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetELLIEEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPathPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInInnerAV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInAV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInWater());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInUpperTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInLowerTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInNeckInnerAV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInNeckAV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetDistInNeckWater());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DU::LightPathCalculator*) G__getstructoffset())->GetTotalDist());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RAT::DU::LightPathCalculator*) G__getstructoffset())->GetTotalDistPartial());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetSolidAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetCosThetaAvg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetFresnelTCoeff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetFresnelRCoeff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetStartPos();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetEndPos();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetLightPathEndPos();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetIncidentVecOnPMT();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetInitialLightVec();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnAV1st();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnAV2nd();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnAV3rd();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnAV4th();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnNeck1st();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPointOnNeck2nd();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = ((RAT::DU::LightPathCalculator*) G__getstructoffset())->GetLightPathType();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetIncidentVecOn1stSurf();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetIncidentVecOn2ndSurf();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetIncidentVecOn3rdSurf();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetIncidentVecOn4thSurf();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetAVInnerRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetAVOuterRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetNeckInnerRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetNeckOuterRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::LightPathCalculator*) G__getstructoffset())->GetPMTRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->SetStartPos(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->SetEndPos(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->SetELLIEEvent((const Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::LightPathCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::LightPathCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::LightPathCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::LightPathCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::LightPathCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::LightPathCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::LightPathCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::LightPathCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1100_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::LightPathCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1100_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::LightPathCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::LightPathCalculator(*(RAT::DU::LightPathCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::LightPathCalculator G__TRATcLcLDUcLcLLightPathCalculator;
static int G__RAT_Dict_1100_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::LightPathCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::LightPathCalculator*) (soff+(sizeof(RAT::DU::LightPathCalculator)*i)))->~G__TRATcLcLDUcLcLLightPathCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::LightPathCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::LightPathCalculator*) (soff))->~G__TRATcLcLDUcLcLLightPathCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1100_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::LightPathCalculator* dest = (RAT::DU::LightPathCalculator*) G__getstructoffset();
   *dest = *(RAT::DU::LightPathCalculator*) libp->para[0].ref;
   const RAT::DU::LightPathCalculator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::PanelInfo */
static int G__RAT_Dict_1110_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PanelInfo*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::PanelInfo*) G__getstructoffset())->GetType((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::PanelInfo*) G__getstructoffset())->GetPanelNumber((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::PanelInfo*) G__getstructoffset())->GetPosition((const size_t) G__int(libp->para[0]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::PanelInfo*) G__getstructoffset())->GetDirection((const size_t) G__int(libp->para[0]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::PanelInfo*) G__getstructoffset())->GetCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::PanelInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PanelInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::PanelInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::PanelInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PanelInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PanelInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PanelInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PanelInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1110_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PanelInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1110_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PanelInfo *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PanelInfo[n];
     } else {
       p = new((void*) gvp) RAT::DU::PanelInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PanelInfo;
     } else {
       p = new((void*) gvp) RAT::DU::PanelInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1110_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::PanelInfo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::PanelInfo(*(RAT::DU::PanelInfo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::PanelInfo G__TRATcLcLDUcLcLPanelInfo;
static int G__RAT_Dict_1110_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::PanelInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::PanelInfo*) (soff+(sizeof(RAT::DU::PanelInfo)*i)))->~G__TRATcLcLDUcLcLPanelInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::PanelInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::PanelInfo*) (soff))->~G__TRATcLcLDUcLcLPanelInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1110_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PanelInfo* dest = (RAT::DU::PanelInfo*) G__getstructoffset();
   *dest = *(RAT::DU::PanelInfo*) libp->para[0].ref;
   const RAT::DU::PanelInfo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ChanHWStatus */
static int G__RAT_Dict_1116_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ChanHWStatus* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ChanHWStatus[n];
     } else {
       p = new((void*) gvp) RAT::DU::ChanHWStatus[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ChanHWStatus;
     } else {
       p = new((void*) gvp) RAT::DU::ChanHWStatus;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ChanHWStatus*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetWord((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetThreshold((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetThresholdZero((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetThresholdAboveNoise((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetMBID((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->GetDBID((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsTubeOnline((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsTubeAtHighVoltage((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsChannelOnline((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsDAQEnabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsNHit100Enabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsNHit20Enabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsEsumLowEnabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsEsumHighEnabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsSequencerEnabled((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ChanHWStatus*) G__getstructoffset())->IsECAChannelActive((const unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::ChanHWStatus::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanHWStatus::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::ChanHWStatus::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::ChanHWStatus::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ChanHWStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanHWStatus::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::ChanHWStatus::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::ChanHWStatus::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1116_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::ChanHWStatus::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1116_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ChanHWStatus* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ChanHWStatus(*(RAT::DU::ChanHWStatus*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ChanHWStatus G__TRATcLcLDUcLcLChanHWStatus;
static int G__RAT_Dict_1116_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ChanHWStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ChanHWStatus*) (soff+(sizeof(RAT::DU::ChanHWStatus)*i)))->~G__TRATcLcLDUcLcLChanHWStatus();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ChanHWStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ChanHWStatus*) (soff))->~G__TRATcLcLDUcLcLChanHWStatus();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1116_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ChanHWStatus* dest = (RAT::DU::ChanHWStatus*) G__getstructoffset();
   *dest = *(RAT::DU::ChanHWStatus*) libp->para[0].ref;
   const RAT::DU::ChanHWStatus& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::PMTCalStatus */
static int G__RAT_Dict_1123_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PMTCalStatus* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PMTCalStatus[n];
     } else {
       p = new((void*) gvp) RAT::DU::PMTCalStatus[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::PMTCalStatus;
     } else {
       p = new((void*) gvp) RAT::DU::PMTCalStatus;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PMTCalStatus*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DU::PMTCalStatus*) G__getstructoffset())->GetCellStatus((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::PMTCalStatus*) G__getstructoffset())->GetChannelStatus((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<int>* pobj;
         vector<int> xobj = ((RAT::DU::PMTCalStatus*) G__getstructoffset())->FlagHits();
         pobj = new vector<int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PMTCalStatus*) G__getstructoffset())->FillFlag(*(vector<int>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::PMTCalStatus::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTCalStatus::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::PMTCalStatus::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::PMTCalStatus::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::PMTCalStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTCalStatus::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PMTCalStatus::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::PMTCalStatus::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::PMTCalStatus::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DU::PMTCalStatus*) G__getstructoffset())->GetHitStatus<RAT::DS::PMTCal>(*(RAT::DS::PMTCal*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1123_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DU::PMTCalStatus*) G__getstructoffset())->GetHitStatus<RAT::FitterPMT>(*(RAT::FitterPMT*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1123_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::PMTCalStatus* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::PMTCalStatus(*(RAT::DU::PMTCalStatus*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::PMTCalStatus G__TRATcLcLDUcLcLPMTCalStatus;
static int G__RAT_Dict_1123_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::PMTCalStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::PMTCalStatus*) (soff+(sizeof(RAT::DU::PMTCalStatus)*i)))->~G__TRATcLcLDUcLcLPMTCalStatus();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::PMTCalStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::PMTCalStatus*) (soff))->~G__TRATcLcLDUcLcLPMTCalStatus();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1123_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::PMTCalStatus* dest = (RAT::DU::PMTCalStatus*) G__getstructoffset();
   *dest = *(RAT::DU::PMTCalStatus*) libp->para[0].ref;
   const RAT::DU::PMTCalStatus& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ReactorNuOsc */
static int G__RAT_Dict_1125_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReactorNuOsc*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1125_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ReactorNuOsc*) G__getstructoffset())->ReactorOsc((const double) G__double(libp->para[0]), *((string*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1125_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReactorNuOsc*) G__getstructoffset())->OscProbability(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1125_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ReactorNuOsc*) G__getstructoffset())->Sample());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1125_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReactorNuOsc *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReactorNuOsc[n];
     } else {
       p = new((void*) gvp) RAT::DU::ReactorNuOsc[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReactorNuOsc;
     } else {
       p = new((void*) gvp) RAT::DU::ReactorNuOsc;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ReactorNuOsc* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ReactorNuOsc(*(RAT::DU::ReactorNuOsc*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ReactorNuOsc G__TRATcLcLDUcLcLReactorNuOsc;
static int G__RAT_Dict_1125_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ReactorNuOsc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ReactorNuOsc*) (soff+(sizeof(RAT::DU::ReactorNuOsc)*i)))->~G__TRATcLcLDUcLcLReactorNuOsc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ReactorNuOsc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ReactorNuOsc*) (soff))->~G__TRATcLcLDUcLcLReactorNuOsc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1125_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReactorNuOsc* dest = (RAT::DU::ReactorNuOsc*) G__getstructoffset();
   *dest = *(RAT::DU::ReactorNuOsc*) libp->para[0].ref;
   const RAT::DU::ReactorNuOsc& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ShadowingCalculator */
static int G__RAT_Dict_1126_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForAVHDRopeShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForSupportRopeShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForBellyPlateShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForNCDAnchorShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForAVPipeShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForNeckBossShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->CheckForShadowing(*(RAT::DU::LightPathCalculator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetAVHDRopeShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetBellyPlateShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetNCDAnchorShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetSupportRopeShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetAVPipeShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetNeckBossShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::DU::ShadowingCalculator*) G__getstructoffset())->GetShadowFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetAllGeometryTolerances((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetAVHDRopeTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetSupportRopeTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetBellyPlateTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetNCDAnchorTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetAVPipeTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1126_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ShadowingCalculator*) G__getstructoffset())->SetNeckBossTolerance((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1126_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ShadowingCalculator *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ShadowingCalculator[n];
     } else {
       p = new((void*) gvp) RAT::DU::ShadowingCalculator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ShadowingCalculator;
     } else {
       p = new((void*) gvp) RAT::DU::ShadowingCalculator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1126_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ShadowingCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ShadowingCalculator(*(RAT::DU::ShadowingCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ShadowingCalculator G__TRATcLcLDUcLcLShadowingCalculator;
static int G__RAT_Dict_1126_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ShadowingCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ShadowingCalculator*) (soff+(sizeof(RAT::DU::ShadowingCalculator)*i)))->~G__TRATcLcLDUcLcLShadowingCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ShadowingCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ShadowingCalculator*) (soff))->~G__TRATcLcLDUcLcLShadowingCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1126_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ShadowingCalculator* dest = (RAT::DU::ShadowingCalculator*) G__getstructoffset();
   *dest = *(RAT::DU::ShadowingCalculator*) libp->para[0].ref;
   const RAT::DU::ShadowingCalculator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::Segmentor */
static int G__RAT_Dict_1127_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Segmentor* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::Segmentor[n];
     } else {
       p = new((void*) gvp) RAT::DU::Segmentor[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::Segmentor;
     } else {
       p = new((void*) gvp) RAT::DU::Segmentor;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->SetNumberOfDivisions((const unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::DU::Segmentor*) G__getstructoffset())->GetNumberOfDivisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->SetPatternZaxis(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->SetPatternZaxis(*(TVector3*) libp->para[0].ref, (const int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->SetPatternOrigin(*(TVector3*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const int) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetPatternOrigin();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetPatternZaxis();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetPatternXaxis();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetPatternYaxis();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<unsigned int>* pobj;
         const vector<unsigned int> xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetSegmentIDs();
         pobj = new vector<unsigned int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<unsigned int>* pobj;
         const vector<unsigned int> xobj = ((const RAT::DU::Segmentor*) G__getstructoffset())->GetSegmentPopulations();
         pobj = new vector<unsigned int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::Segmentor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Segmentor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::Segmentor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Segmentor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Segmentor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Segmentor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Segmentor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Segmentor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1127_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Segmentor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1127_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::Segmentor* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::Segmentor(*(RAT::DU::Segmentor*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::Segmentor G__TRATcLcLDUcLcLSegmentor;
static int G__RAT_Dict_1127_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::Segmentor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::Segmentor*) (soff+(sizeof(RAT::DU::Segmentor)*i)))->~G__TRATcLcLDUcLcLSegmentor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::Segmentor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::Segmentor*) (soff))->~G__TRATcLcLDUcLcLSegmentor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1127_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Segmentor* dest = (RAT::DU::Segmentor*) G__getstructoffset();
   *dest = *(RAT::DU::Segmentor*) libp->para[0].ref;
   const RAT::DU::Segmentor& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::SOCReader */
static int G__RAT_Dict_1128_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::SOCReader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::SOCReader(*(string*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::DU::SOCReader(*(string*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::SOCReader(*(string*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::DU::SOCReader(*(string*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::SOCReader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::SOCReader(*(vector<std::string>*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::DU::SOCReader(*(vector<std::string>*) libp->para[0].ref, (const bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::SOCReader(*(vector<std::string>*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RAT::DU::SOCReader(*(vector<std::string>*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::SOCReader*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::SOCReader*) G__getstructoffset())->Add(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::SOC& obj = ((RAT::DU::SOCReader*) G__getstructoffset())->GetSOC((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((RAT::DU::SOCReader*) G__getstructoffset())->GetSOCCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::SOCReader*) G__getstructoffset())->GetRun();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::SOCReader*) G__getstructoffset())->GetRunByRunID((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Run& obj = ((RAT::DU::SOCReader*) G__getstructoffset())->GetRunByIndex((const size_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((RAT::DU::SOCReader*) G__getstructoffset())->GetRunCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::SOCReader::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::SOCReader::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::SOCReader::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::SOCReader::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::SOCReader*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::SOCReader::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::SOCReader::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::SOCReader::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1128_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::SOCReader::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1128_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::SOCReader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::SOCReader(*(RAT::DU::SOCReader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::SOCReader G__TRATcLcLDUcLcLSOCReader;
static int G__RAT_Dict_1128_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::SOCReader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::SOCReader*) (soff+(sizeof(RAT::DU::SOCReader)*i)))->~G__TRATcLcLDUcLcLSOCReader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::SOCReader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::SOCReader*) (soff))->~G__TRATcLcLDUcLcLSOCReader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1128_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::SOCReader* dest = (RAT::DU::SOCReader*) G__getstructoffset();
   *dest = *(RAT::DU::SOCReader*) libp->para[0].ref;
   const RAT::DU::SOCReader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ReconCorrector */
static int G__RAT_Dict_1129_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::ReconCorrector::Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReconCorrector* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReconCorrector[n];
     } else {
       p = new((void*) gvp) RAT::DU::ReconCorrector[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReconCorrector;
     } else {
       p = new((void*) gvp) RAT::DU::ReconCorrector;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReconCorrector*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReconCorrector*) G__getstructoffset())->Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCorrector*) G__getstructoffset())->CorrectRSPTables((const double) G__double(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref
, *(vector<double>*) libp->para[4].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCorrector*) G__getstructoffset())->CorrectEnergyRSP((double) G__double(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCorrector*) G__getstructoffset())->CorrectEnergyRSP((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCorrector*) G__getstructoffset())->Interpolate1D((double) G__double(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ReconCorrector* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ReconCorrector(*(RAT::DU::ReconCorrector*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ReconCorrector G__TRATcLcLDUcLcLReconCorrector;
static int G__RAT_Dict_1129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ReconCorrector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ReconCorrector*) (soff+(sizeof(RAT::DU::ReconCorrector)*i)))->~G__TRATcLcLDUcLcLReconCorrector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ReconCorrector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ReconCorrector*) (soff))->~G__TRATcLcLDUcLcLReconCorrector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReconCorrector* dest = (RAT::DU::ReconCorrector*) G__getstructoffset();
   *dest = *(RAT::DU::ReconCorrector*) libp->para[0].ref;
   const RAT::DU::ReconCorrector& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::ReconCalibrator */
static int G__RAT_Dict_1130_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::ReconCalibrator::Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1130_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReconCalibrator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReconCalibrator[n];
     } else {
       p = new((void*) gvp) RAT::DU::ReconCalibrator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::ReconCalibrator;
     } else {
       p = new((void*) gvp) RAT::DU::ReconCalibrator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1130_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReconCalibrator*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::ReconCalibrator*) G__getstructoffset())->Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1130_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCalibrator*) G__getstructoffset())->CalibrateEnergyRSP((bool) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (int) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCalibrator*) G__getstructoffset())->CalibrateEnergyRSP((bool) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const RAT::DU::ReconCalibrator*) G__getstructoffset())->CalibrateEnergyRSP((bool) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1130_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::ReconCalibrator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::ReconCalibrator(*(RAT::DU::ReconCalibrator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::ReconCalibrator G__TRATcLcLDUcLcLReconCalibrator;
static int G__RAT_Dict_1130_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::ReconCalibrator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::ReconCalibrator*) (soff+(sizeof(RAT::DU::ReconCalibrator)*i)))->~G__TRATcLcLDUcLcLReconCalibrator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::ReconCalibrator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::ReconCalibrator*) (soff))->~G__TRATcLcLDUcLcLReconCalibrator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1130_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::ReconCalibrator* dest = (RAT::DU::ReconCalibrator*) G__getstructoffset();
   *dest = *(RAT::DU::ReconCalibrator*) libp->para[0].ref;
   const RAT::DU::ReconCalibrator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::FitterPMT */
static int G__RAT_Dict_1131_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::FitterPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::FitterPMT[n];
     } else {
       p = new((void*) gvp) RAT::FitterPMT[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::FitterPMT;
     } else {
       p = new((void*) gvp) RAT::FitterPMT;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::FitterPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::FitterPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RAT::FitterPMT(*(RAT::DS::PMTCal*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::FitterPMT* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::FitterPMT(*(RAT::DS::SOCPMT*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RAT::FitterPMT(*(RAT::DS::SOCPMT*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::FitterPMT*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::FitterPMT*) G__getstructoffset())->GetCCCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetTimeError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQHL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQHLError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQHS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQHSError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQLX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::FitterPMT*) G__getstructoffset())->GetQLXError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::BitMask* pobj;
         const RAT::DS::BitMask xobj = ((const RAT::FitterPMT*) G__getstructoffset())->GetStatus();
         pobj = new RAT::DS::BitMask(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1131_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::FitterPMT*) G__getstructoffset())->GetCrossTalkFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1131_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::FitterPMT* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::FitterPMT(*(RAT::FitterPMT*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::FitterPMT G__TRATcLcLFitterPMT;
static int G__RAT_Dict_1131_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::FitterPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::FitterPMT*) (soff+(sizeof(RAT::FitterPMT)*i)))->~G__TRATcLcLFitterPMT();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::FitterPMT*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::FitterPMT*) (soff))->~G__TRATcLcLFitterPMT();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1131_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::FitterPMT* dest = (RAT::FitterPMT*) G__getstructoffset();
   *dest = *(RAT::FitterPMT*) libp->para[0].ref;
   const RAT::FitterPMT& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::TimeResidualCalculator */
static int G__RAT_Dict_1132_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::TimeResidualCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::TimeResidualCalculator[n];
     } else {
       p = new((void*) gvp) RAT::DU::TimeResidualCalculator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::TimeResidualCalculator;
     } else {
       p = new((void*) gvp) RAT::DU::TimeResidualCalculator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(
*(RAT::DS::PMTCal*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4]), (const Bool_t) G__int(libp->para[5])
, (const Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::DS::PMTCal*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4]), (const Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::DS::PMTCal*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::DS::PMTCal*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::DS::PMTCal*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(
*(RAT::FitterPMT*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4]), (const Bool_t) G__int(libp->para[5])
, (const Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::FitterPMT*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4]), (const Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::FitterPMT*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])
, (const Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::FitterPMT*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2]), (const Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(*(RAT::FitterPMT*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (const double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(
(const UInt_t) G__int(libp->para[0]), (const double) G__double(libp->para[1])
, *(TVector3*) libp->para[2].ref, (const double) G__double(libp->para[3])
, (const Bool_t) G__int(libp->para[4]), (const Double_t) G__double(libp->para[5])
, (const Bool_t) G__int(libp->para[6]), (const Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual(
(const UInt_t) G__int(libp->para[0]), (const double) G__double(libp->para[1])
, *(TVector3*) libp->para[2].ref, (const double) G__double(libp->para[3])
, (const Bool_t) G__int(libp->para[4]), (const Double_t) G__double(libp->para[5])
, (const Bool_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual((const UInt_t) G__int(libp->para[0]), (const double) G__double(libp->para[1])
, *(TVector3*) libp->para[2].ref, (const double) G__double(libp->para[3])
, (const Bool_t) G__int(libp->para[4]), (const Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual((const UInt_t) G__int(libp->para[0]), (const double) G__double(libp->para[1])
, *(TVector3*) libp->para[2].ref, (const double) G__double(libp->para[3])
, (const Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->CalcTimeResidual((const UInt_t) G__int(libp->para[0]), (const double) G__double(libp->para[1])
, *(TVector3*) libp->para[2].ref, (const double) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::TimeResidualCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TimeResidualCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::TimeResidualCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::TimeResidualCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::TimeResidualCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TimeResidualCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::TimeResidualCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::TimeResidualCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1132_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::TimeResidualCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1132_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::TimeResidualCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::TimeResidualCalculator(*(RAT::DU::TimeResidualCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::TimeResidualCalculator G__TRATcLcLDUcLcLTimeResidualCalculator;
static int G__RAT_Dict_1132_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::TimeResidualCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::TimeResidualCalculator*) (soff+(sizeof(RAT::DU::TimeResidualCalculator)*i)))->~G__TRATcLcLDUcLcLTimeResidualCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::TimeResidualCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::TimeResidualCalculator*) (soff))->~G__TRATcLcLDUcLcLTimeResidualCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1132_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::TimeResidualCalculator* dest = (RAT::DU::TimeResidualCalculator*) G__getstructoffset();
   *dest = *(RAT::DU::TimeResidualCalculator*) libp->para[0].ref;
   const RAT::DU::TimeResidualCalculator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::Utility */
static int G__RAT_Dict_1133_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::Utility::Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Utility::LoadDBAndBeginRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Utility*) G__getstructoffset())->BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::PMTInfo& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetPMTInfo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::PanelInfo& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetPanelInfo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ChanHWStatus& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetChanHWStatus();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::PMTCalStatus& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetPMTCalStatus();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ReactorNuOsc& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetReactorNuOsc();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Segmentor& obj = ((RAT::DU::Utility*) G__getstructoffset())->GetSegmentor();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DU::LightPathCalculator* pobj;
         RAT::DU::LightPathCalculator xobj = ((RAT::DU::Utility*) G__getstructoffset())->GetLightPathCalculator();
         pobj = new RAT::DU::LightPathCalculator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::GroupVelocity& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetGroupVelocity();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::EffectiveVelocity& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetEffectiveVelocity();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::DataCleaningBits& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetDataCleaningBits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::DataQualityBits& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetDataQualityBits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ChanSWStatus& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetChanSWStatus();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::TrigBits& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetTrigBits();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ShadowingCalculator& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetShadowingCalculator();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ReconCorrector& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetReconCorrector();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::ReconCalibrator& obj = ((const RAT::DU::Utility*) G__getstructoffset())->GetReconCalibrator();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DU::TimeResidualCalculator* pobj;
         RAT::DU::TimeResidualCalculator xobj = ((RAT::DU::Utility*) G__getstructoffset())->GetTimeResidualCalculator();
         pobj = new RAT::DU::TimeResidualCalculator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Utility* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DU::Utility((TRootIOCtor*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::DU::Utility((TRootIOCtor*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::Utility::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Utility::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::Utility::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Utility::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Utility*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Utility::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Utility::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Utility::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1133_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Utility::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::Utility G__TRATcLcLDUcLcLUtility;
static int G__RAT_Dict_1133_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::Utility*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::Utility*) (soff+(sizeof(RAT::DU::Utility)*i)))->~G__TRATcLcLDUcLcLUtility();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::Utility*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::Utility*) (soff))->~G__TRATcLcLDUcLcLUtility();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::TrackNode */
static int G__RAT_Dict_1135_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNode[n];
     } else {
       p = new((void*) gvp) RAT::TrackNode[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNode;
     } else {
       p = new((void*) gvp) RAT::TrackNode;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::TrackNode*) G__getstructoffset())->IsTrackStart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::TrackNode*) G__getstructoffset())->SetTrackStart((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::TrackNode*) G__getstructoffset())->SetTrackStart();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::TrackNode*) G__getstructoffset())->IsTrackEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackNode*) G__getstructoffset())->GetTrackID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetTrackID((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackNode*) G__getstructoffset())->GetStepID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetStepID((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackNode*) G__getstructoffset())->GetPDGCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetPDGCode((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const RAT::TrackNode*) G__getstructoffset())->GetParticleName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetParticleName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackNode*) G__getstructoffset())->GetPrev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetPrev((RAT::TrackNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackNode*) G__getstructoffset())->GetNext());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->SetNext((RAT::TrackNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->AddNext((RAT::TrackNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->AddChild((RAT::TrackNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::TrackNode& obj = ((RAT::TrackNode*) G__getstructoffset())->operator=(*(RAT::DS::MCTrackStep*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::TrackNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::TrackNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::TrackNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::TrackNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::TrackNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::TrackNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::TrackNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1135_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::TrackNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1135_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::TrackNode* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::TrackNode(*(RAT::TrackNode*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::TrackNode G__TRATcLcLTrackNode;
static int G__RAT_Dict_1135_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::TrackNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::TrackNode*) (soff+(sizeof(RAT::TrackNode)*i)))->~G__TRATcLcLTrackNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::TrackNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::TrackNode*) (soff))->~G__TRATcLcLTrackNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1135_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackNode* dest = (RAT::TrackNode*) G__getstructoffset();
   *dest = *(RAT::TrackNode*) libp->para[0].ref;
   const RAT::TrackNode& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > */
static int G__RAT_Dict_1137_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reference obj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->at((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_reference obj = ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->at((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator* pobj;
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator xobj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator* pobj;
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator xobj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator* pobj;
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator xobj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator* pobj;
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator xobj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->resize((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->resize((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]), (RAT::TrackNode*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reference obj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->operator[]((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_reference obj = ((const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->operator[]((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >;
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(RAT::TrackNode**) libp->para[1].ref : *(RAT::TrackNode**) (void*) (&G__Mlong(libp->para[1])));
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(RAT::TrackNode**) libp->para[1].ref : *(RAT::TrackNode**) (void*) (&G__Mlong(libp->para[1])));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >(*(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >(*(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >& obj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->operator=(*(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->reserve((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::TrackNode*& obj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::TrackNode*& obj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->push_back(libp->para[0].ref ? *(RAT::TrackNode**) libp->para[0].ref : *(RAT::TrackNode**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->swap(*(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator* pobj;
         vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator xobj = ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[0])), libp->para[1].ref ? *(RAT::TrackNode**) libp->para[1].ref : *(RAT::TrackNode**) (void*) (&G__Mlong(libp->para[1])));
         pobj = new vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[0])), (vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type) G__int(libp->para[1])
, libp->para[2].ref ? *(RAT::TrackNode**) libp->para[2].ref : *(RAT::TrackNode**) (void*) (&G__Mlong(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->erase(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->erase(*((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1137_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > G__TvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR;
static int G__RAT_Dict_1137_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) (soff+(sizeof(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >)*i)))->~G__TvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*) (soff))->~G__TvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::TrackCursor */
static int G__RAT_Dict_1142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackCursor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackCursor((RAT::TrackNode*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::TrackCursor((RAT::TrackNode*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackCursor((RAT::TrackNode*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RAT::TrackCursor((RAT::TrackNode*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RAT::TrackCursor*) G__getstructoffset())->GetVerbose());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RAT::TrackCursor*) G__getstructoffset())->SetVerbose((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RAT::TrackCursor*) G__getstructoffset())->SetVerbose();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->TrackStart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Prev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Here());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->TrackEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackCursor*) G__getstructoffset())->StepCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Step((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackCursor*) G__getstructoffset())->ChildCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Child((size_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Child());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::TrackCursor*) G__getstructoffset())->TrackChildCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->TrackChild((size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RAT::TrackCursor*) G__getstructoffset())->Parent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::TrackCursor*) G__getstructoffset())->TrackLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::TrackCursor*) G__getstructoffset())->IsTrackStart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::TrackCursor*) G__getstructoffset())->IsTrackEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackCursor*) G__getstructoffset())->Go((RAT::TrackNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoTrackStart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoPrev());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoNext());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoTrackEnd());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoStep((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoChild((int) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoChild());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoTrackChild((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->GoParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RAT::TrackCursor*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RAT::TrackCursor*) G__getstructoffset())->PrintTrack();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::TrackCursor::PrintTrackIDs((RAT::TrackNode*) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::TrackCursor::Print((RAT::TrackNode*) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::TrackCursor::PrintTrack((RAT::TrackNode*) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->FindNextTrack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->FindNextTrackNoDescend());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->FindNextTrack((RAT::TrackTest*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1142_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackCursor*) G__getstructoffset())->FindNextParticle(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1142_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::TrackCursor* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::TrackCursor(*(RAT::TrackCursor*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::TrackCursor G__TRATcLcLTrackCursor;
static int G__RAT_Dict_1142_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::TrackCursor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::TrackCursor*) (soff+(sizeof(RAT::TrackCursor)*i)))->~G__TRATcLcLTrackCursor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::TrackCursor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::TrackCursor*) (soff))->~G__TRATcLcLTrackCursor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1142_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackCursor* dest = (RAT::TrackCursor*) G__getstructoffset();
   *dest = *(RAT::TrackCursor*) libp->para[0].ref;
   const RAT::TrackCursor& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::TrackNav */
static int G__RAT_Dict_1144_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackNav* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNav((RAT::DS::Entry*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::TrackNav((RAT::DS::Entry*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNav((RAT::DS::Entry*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RAT::TrackNav((RAT::DS::Entry*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackNav* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNav((RAT::DS::MC*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RAT::TrackNav((RAT::DS::MC*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::TrackNav((RAT::DS::MC*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RAT::TrackNav((RAT::DS::MC*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RAT::TrackNav*) G__getstructoffset())->Load((RAT::DS::MC*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RAT::TrackNav*) G__getstructoffset())->Load((RAT::DS::MC*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::TrackNav*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackNav*) G__getstructoffset())->Head());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         RAT::TrackCursor* pobj;
         RAT::TrackCursor xobj = ((RAT::TrackNav*) G__getstructoffset())->Cursor((bool) G__int(libp->para[0]));
         pobj = new RAT::TrackCursor(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         RAT::TrackCursor* pobj;
         RAT::TrackCursor xobj = ((RAT::TrackNav*) G__getstructoffset())->Cursor();
         pobj = new RAT::TrackCursor(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RAT::TrackNav*) G__getstructoffset())->FindID((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1144_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((RAT::TrackNav*) G__getstructoffset())->FindParticle(*(string*) libp->para[0].ref, (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RAT::TrackNav*) G__getstructoffset())->FindParticle(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1144_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::TrackNav* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::TrackNav(*(RAT::TrackNav*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::TrackNav G__TRATcLcLTrackNav;
static int G__RAT_Dict_1144_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::TrackNav*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::TrackNav*) (soff+(sizeof(RAT::TrackNav)*i)))->~G__TRATcLcLTrackNav();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::TrackNav*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::TrackNav*) (soff))->~G__TRATcLcLTrackNav();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1144_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::TrackNav* dest = (RAT::TrackNav*) G__getstructoffset();
   *dest = *(RAT::TrackNav*) libp->para[0].ref;
   const RAT::TrackNav& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DBCommandLoader */
static int G__RAT_Dict_1167_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DBCommandLoader::LoadCommands(*(RAT::DS::Meta*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1167_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DBCommandLoader::LoadCommand(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1167_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DBCommandLoader::LoadFile(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1167_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBCommandLoader *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBCommandLoader[n];
     } else {
       p = new((void*) gvp) RAT::DBCommandLoader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBCommandLoader;
     } else {
       p = new((void*) gvp) RAT::DBCommandLoader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1167_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DBCommandLoader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DBCommandLoader(*(RAT::DBCommandLoader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DBCommandLoader G__TRATcLcLDBCommandLoader;
static int G__RAT_Dict_1167_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DBCommandLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DBCommandLoader*) (soff+(sizeof(RAT::DBCommandLoader)*i)))->~G__TRATcLcLDBCommandLoader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DBCommandLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DBCommandLoader*) (soff))->~G__TRATcLcLDBCommandLoader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1167_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBCommandLoader* dest = (RAT::DBCommandLoader*) G__getstructoffset();
   const RAT::DBCommandLoader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DBTextLoader */
static int G__RAT_Dict_1195_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*>* pobj;
         vector<RAT::DBTable*> xobj = RAT::DBTextLoader::parse(*((string*) G__int(libp->para[0])));
         pobj = new vector<RAT::DBTable*>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1195_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTextLoader *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTextLoader[n];
     } else {
       p = new((void*) gvp) RAT::DBTextLoader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBTextLoader;
     } else {
       p = new((void*) gvp) RAT::DBTextLoader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1195_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DBTextLoader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DBTextLoader(*(RAT::DBTextLoader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DBTextLoader G__TRATcLcLDBTextLoader;
static int G__RAT_Dict_1195_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DBTextLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DBTextLoader*) (soff+(sizeof(RAT::DBTextLoader)*i)))->~G__TRATcLcLDBTextLoader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DBTextLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DBTextLoader*) (soff))->~G__TRATcLcLDBTextLoader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1195_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBTextLoader* dest = (RAT::DBTextLoader*) G__getstructoffset();
   const RAT::DBTextLoader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DBJsonLoader */
static int G__RAT_Dict_1196_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*>* pobj;
         vector<RAT::DBTable*> xobj = RAT::DBJsonLoader::parse(*(string*) libp->para[0].ref);
         pobj = new vector<RAT::DBTable*>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1196_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable*>* pobj;
         vector<RAT::DBTable*> xobj = RAT::DBJsonLoader::parseString(*(string*) libp->para[0].ref);
         pobj = new vector<RAT::DBTable*>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1196_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DBJsonLoader::convertTable(*(json::Value*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1196_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBJsonLoader *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBJsonLoader[n];
     } else {
       p = new((void*) gvp) RAT::DBJsonLoader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DBJsonLoader;
     } else {
       p = new((void*) gvp) RAT::DBJsonLoader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DBJsonLoader* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DBJsonLoader(*(RAT::DBJsonLoader*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DBJsonLoader G__TRATcLcLDBJsonLoader;
static int G__RAT_Dict_1196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DBJsonLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DBJsonLoader*) (soff+(sizeof(RAT::DBJsonLoader)*i)))->~G__TRATcLcLDBJsonLoader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DBJsonLoader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DBJsonLoader*) (soff))->~G__TRATcLcLDBJsonLoader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DBJsonLoader* dest = (RAT::DBJsonLoader*) G__getstructoffset();
   const RAT::DBJsonLoader& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::HTTPDownloader */
static int G__RAT_Dict_1197_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::HTTPDownloader* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::HTTPDownloader[n];
     } else {
       p = new((void*) gvp) RAT::HTTPDownloader[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::HTTPDownloader;
     } else {
       p = new((void*) gvp) RAT::HTTPDownloader;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLHTTPDownloader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::HTTPDownloader*) G__getstructoffset())->Disconnect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1197_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = ((RAT::HTTPDownloader*) G__getstructoffset())->Fetch(*(string*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::HTTPDownloader G__TRATcLcLHTTPDownloader;
static int G__RAT_Dict_1197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::HTTPDownloader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::HTTPDownloader*) (soff+(sizeof(RAT::HTTPDownloader)*i)))->~G__TRATcLcLHTTPDownloader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::HTTPDownloader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::HTTPDownloader*) (soff))->~G__TRATcLcLHTTPDownloader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::MetaInformation */
static int G__RAT_Dict_1198_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::MetaInformation::Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::MetaInformation*) G__getstructoffset())->Initialise();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::MetaInformation*) G__getstructoffset())->Initialise((RAT::DS::Meta*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::MetaInformation*) G__getstructoffset())->Finalise(*(RAT::MetaHelper*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::MetaInformation*) G__getstructoffset())->AddOverrideCommand(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::MetaInformation*) G__getstructoffset())->AddLoadCommand(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DS::Meta& obj = ((const RAT::MetaInformation*) G__getstructoffset())->GetDSMeta();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::MetaInformation*) G__getstructoffset())->GetCurrentPass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1198_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::MetaInformation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::MetaInformation((TRootIOCtor*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RAT::MetaInformation((TRootIOCtor*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::MetaInformation* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::MetaInformation(*(RAT::MetaInformation*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::MetaInformation G__TRATcLcLMetaInformation;
static int G__RAT_Dict_1198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::MetaInformation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::MetaInformation*) (soff+(sizeof(RAT::MetaInformation)*i)))->~G__TRATcLcLMetaInformation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::MetaInformation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::MetaInformation*) (soff))->~G__TRATcLcLMetaInformation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::MetaInformation* dest = (RAT::MetaInformation*) G__getstructoffset();
   *dest = *(RAT::MetaInformation*) libp->para[0].ref;
   const RAT::MetaInformation& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PmtEventRecord */
// automatic default constructor
static int G__RAT_Dict_1199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PmtEventRecord *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new PmtEventRecord[n];
     } else {
       p = new((void*) gvp) PmtEventRecord[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new PmtEventRecord;
     } else {
       p = new((void*) gvp) PmtEventRecord;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PmtEventRecord* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PmtEventRecord(*(PmtEventRecord*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PmtEventRecord G__TPmtEventRecord;
static int G__RAT_Dict_1199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PmtEventRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PmtEventRecord*) (soff+(sizeof(PmtEventRecord)*i)))->~G__TPmtEventRecord();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PmtEventRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PmtEventRecord*) (soff))->~G__TPmtEventRecord();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PmtEventRecord* dest = (PmtEventRecord*) G__getstructoffset();
   *dest = *(PmtEventRecord*) libp->para[0].ref;
   const PmtEventRecord& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RunRecord */
// automatic default constructor
static int G__RAT_Dict_1200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RunRecord *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RunRecord[n];
     } else {
       p = new((void*) gvp) RunRecord[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RunRecord;
     } else {
       p = new((void*) gvp) RunRecord;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RunRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RunRecord* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RunRecord(*(RunRecord*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RunRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RunRecord G__TRunRecord;
static int G__RAT_Dict_1200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RunRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RunRecord*) (soff+(sizeof(RunRecord)*i)))->~G__TRunRecord();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RunRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RunRecord*) (soff))->~G__TRunRecord();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1200_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RunRecord* dest = (RunRecord*) G__getstructoffset();
   *dest = *(RunRecord*) libp->para[0].ref;
   const RunRecord& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TriggerInfo */
// automatic default constructor
static int G__RAT_Dict_1201_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TriggerInfo *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TriggerInfo[n];
     } else {
       p = new((void*) gvp) TriggerInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TriggerInfo;
     } else {
       p = new((void*) gvp) TriggerInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TriggerInfo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TriggerInfo(*(TriggerInfo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TriggerInfo G__TTriggerInfo;
static int G__RAT_Dict_1201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TriggerInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TriggerInfo*) (soff+(sizeof(TriggerInfo)*i)))->~G__TTriggerInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TriggerInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TriggerInfo*) (soff))->~G__TTriggerInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TriggerInfo* dest = (TriggerInfo*) G__getstructoffset();
   *dest = *(TriggerInfo*) libp->para[0].ref;
   const TriggerInfo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* EpedRecord */
// automatic default constructor
static int G__RAT_Dict_1202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EpedRecord *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EpedRecord[n];
     } else {
       p = new((void*) gvp) EpedRecord[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new EpedRecord;
     } else {
       p = new((void*) gvp) EpedRecord;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   EpedRecord* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new EpedRecord(*(EpedRecord*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef EpedRecord G__TEpedRecord;
static int G__RAT_Dict_1202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (EpedRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((EpedRecord*) (soff+(sizeof(EpedRecord)*i)))->~G__TEpedRecord();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (EpedRecord*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((EpedRecord*) (soff))->~G__TEpedRecord();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   EpedRecord* dest = (EpedRecord*) G__getstructoffset();
   *dest = *(EpedRecord*) libp->para[0].ref;
   const EpedRecord& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab */
static int G__RAT_Dict_1203_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<int,int>* pobj;
         map<int,int> xobj = ratzdab::get_pdg_to_snoman_map();
         pobj = new map<int,int>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<int,float>* pobj;
         map<int,float> xobj = ratzdab::get_pdg_to_mass_map();
         pobj = new map<int,float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab::unpack */
static int G__RAT_Dict_1204_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::unpack::event((PmtEventRecord*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::unpack::rhdr((RunRecord*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::unpack::trig((TriggerInfo*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::unpack::eped((EpedRecord*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DS::Digitiser* pobj;
         RAT::DS::Digitiser xobj = ratzdab::unpack::caen((uint32_t *const) G__int(libp->para[0]));
         pobj = new RAT::DS::Digitiser(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         RAT::DS::PMTUncal* pobj;
         RAT::DS::PMTUncal xobj = ratzdab::unpack::pmt((uint32_t *const) G__int(libp->para[0]), (const int) G__int(libp->para[1]));
         pobj = new RAT::DS::PMTUncal(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1204_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ratzdab::unpack::tubii((uint32_t *const) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab::pack */
static int G__RAT_Dict_1205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ratzdab::pack::event((RAT::DS::Entry*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ratzdab::pack::event((RAT::DS::Entry*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::pack::rhdr((RAT::DS::Run*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::pack::trig((RAT::DS::TrigHeader*) G__int(libp->para[0]), (const uint32_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ratzdab::pack::eped((RAT::DS::ECAHeader*) G__int(libp->para[0]), (const uint32_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab::unknown_record_error */
static int G__RAT_Dict_1213_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ratzdab::unknown_record_error*) G__getstructoffset())->what());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__RAT_Dict_1213_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ratzdab::unknown_record_error *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ratzdab::unknown_record_error[n];
     } else {
       p = new((void*) gvp) ratzdab::unknown_record_error[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ratzdab::unknown_record_error;
     } else {
       p = new((void*) gvp) ratzdab::unknown_record_error;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1213_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ratzdab::unknown_record_error* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ratzdab::unknown_record_error(*(ratzdab::unknown_record_error*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ratzdab::unknown_record_error G__TratzdabcLcLunknown_record_error;
static int G__RAT_Dict_1213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ratzdab::unknown_record_error*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ratzdab::unknown_record_error*) (soff+(sizeof(ratzdab::unknown_record_error)*i)))->~G__TratzdabcLcLunknown_record_error();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ratzdab::unknown_record_error*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ratzdab::unknown_record_error*) (soff))->~G__TratzdabcLcLunknown_record_error();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PZdabFile */
static int G__RAT_Dict_1214_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PZdabFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new PZdabFile[n];
     } else {
       p = new((void*) gvp) PZdabFile[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new PZdabFile;
     } else {
       p = new((void*) gvp) PZdabFile;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PZdabFile*) G__getstructoffset())->Init((FILE*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PZdabFile*) G__getstructoffset())->Free();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PZdabFile*) G__getstructoffset())->NextRecord());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PZdabFile*) G__getstructoffset())->NextPmt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) ((PZdabFile*) G__getstructoffset())->NextBank((uint32_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PZdabFile*) G__getstructoffset())->GetPmtRecord((nZDAB*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 72, (long) PZdabFile::GetBank((nZDAB*) G__int(libp->para[0]), (uint32_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 72, (long) PZdabFile::GetBank((nZDAB*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) PZdabFile::GetSize((PmtEventRecord*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) PZdabFile::GetExtendedData((PmtEventRecord*) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 72, (long) PZdabFile::GetNcdData((PmtEventRecord*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      PZdabFile::DumpHex((nZDAB*) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      PZdabFile::DumpHex((nZDAB*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) PZdabFile::BankName((char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PZdabFile::BankNameString((uint32_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1214_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PZdabFile::AddSubField((uint32_t**) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (uint32_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1214_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PZdabFile* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PZdabFile(*(PZdabFile*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PZdabFile G__TPZdabFile;
static int G__RAT_Dict_1214_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PZdabFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PZdabFile*) (soff+(sizeof(PZdabFile)*i)))->~G__TPZdabFile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PZdabFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PZdabFile*) (soff))->~G__TPZdabFile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1214_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PZdabFile* dest = (PZdabFile*) G__getstructoffset();
   *dest = *(PZdabFile*) libp->para[0].ref;
   const PZdabFile& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab::zdabfile */
static int G__RAT_Dict_1216_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ratzdab::zdabfile* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ratzdab::zdabfile(*((string*) G__int(libp->para[0])));
   } else {
     p = new((void*) gvp) ratzdab::zdabfile(*((string*) G__int(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1216_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((ratzdab::zdabfile*) G__getstructoffset())->next());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1216_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ratzdab::zdabfile* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ratzdab::zdabfile(*(ratzdab::zdabfile*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ratzdab::zdabfile G__TratzdabcLcLzdabfile;
static int G__RAT_Dict_1216_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ratzdab::zdabfile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ratzdab::zdabfile*) (soff+(sizeof(ratzdab::zdabfile)*i)))->~G__TratzdabcLcLzdabfile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ratzdab::zdabfile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ratzdab::zdabfile*) (soff))->~G__TratzdabcLcLzdabfile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ratzdab::zdabfile::zdab_file_read_error */
// automatic default constructor
static int G__RAT_Dict_1217_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ratzdab::zdabfile::zdab_file_read_error *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ratzdab::zdabfile::zdab_file_read_error[n];
     } else {
       p = new((void*) gvp) ratzdab::zdabfile::zdab_file_read_error[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ratzdab::zdabfile::zdab_file_read_error;
     } else {
       p = new((void*) gvp) ratzdab::zdabfile::zdab_file_read_error;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1217_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ratzdab::zdabfile::zdab_file_read_error* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ratzdab::zdabfile::zdab_file_read_error(*(ratzdab::zdabfile::zdab_file_read_error*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ratzdab::zdabfile::zdab_file_read_error G__TratzdabcLcLzdabfilecLcLzdab_file_read_error;
static int G__RAT_Dict_1217_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ratzdab::zdabfile::zdab_file_read_error*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ratzdab::zdabfile::zdab_file_read_error*) (soff+(sizeof(ratzdab::zdabfile::zdab_file_read_error)*i)))->~G__TratzdabcLcLzdabfilecLcLzdab_file_read_error();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ratzdab::zdabfile::zdab_file_read_error*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ratzdab::zdabfile::zdab_file_read_error*) (soff))->~G__TratzdabcLcLzdabfilecLcLzdab_file_read_error();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* ManipRopeStatus */
// automatic default constructor
static int G__RAT_Dict_1225_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ManipRopeStatus *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ManipRopeStatus[n];
     } else {
       p = new((void*) gvp) ManipRopeStatus[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ManipRopeStatus;
     } else {
       p = new((void*) gvp) ManipRopeStatus;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1225_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   ManipRopeStatus* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new ManipRopeStatus(*(ManipRopeStatus*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef ManipRopeStatus G__TManipRopeStatus;
static int G__RAT_Dict_1225_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (ManipRopeStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((ManipRopeStatus*) (soff+(sizeof(ManipRopeStatus)*i)))->~G__TManipRopeStatus();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (ManipRopeStatus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((ManipRopeStatus*) (soff))->~G__TManipRopeStatus();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1225_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ManipRopeStatus* dest = (ManipRopeStatus*) G__getstructoffset();
   *dest = *(ManipRopeStatus*) libp->para[0].ref;
   const ManipRopeStatus& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* MTCReadoutData */
// automatic default constructor
static int G__RAT_Dict_1237_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MTCReadoutData *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MTCReadoutData[n];
     } else {
       p = new((void*) gvp) MTCReadoutData[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new MTCReadoutData;
     } else {
       p = new((void*) gvp) MTCReadoutData;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1237_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   MTCReadoutData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new MTCReadoutData(*(MTCReadoutData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef MTCReadoutData G__TMTCReadoutData;
static int G__RAT_Dict_1237_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (MTCReadoutData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((MTCReadoutData*) (soff+(sizeof(MTCReadoutData)*i)))->~G__TMTCReadoutData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (MTCReadoutData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((MTCReadoutData*) (soff))->~G__TMTCReadoutData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1237_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MTCReadoutData* dest = (MTCReadoutData*) G__getstructoffset();
   *dest = *(MTCReadoutData*) libp->para[0].ref;
   const MTCReadoutData& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::util */
static int G__RAT_Dict_1254_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::util::EnergyToWavelength(*(double*) G__Doubleref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::util::WavelengthToEnergy(*(double*) G__Doubleref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1254_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::util::round_2_int(*(double*) G__Doubleref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::util::round_2_int(*(float*) G__Floatref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::EnergySystematics */
static int G__RAT_Dict_1282_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::EnergySystematics* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DU::EnergySystematics((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) RAT::DU::EnergySystematics((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::EnergySystematics*) G__getstructoffset())->ApplyEnergyResolution(*(double*) G__Doubleref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const RAT::DU::EnergySystematics*) G__getstructoffset())->ApplyEnergyScale(*(double*) G__Doubleref(&libp->para[0]), *(bool*) G__Boolref(&libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const RAT::DU::EnergySystematics*) G__getstructoffset())->ApplyEnergyScale(*(double*) G__Doubleref(&libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::EnergySystematics::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EnergySystematics::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::EnergySystematics::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::EnergySystematics::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::EnergySystematics*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EnergySystematics::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::EnergySystematics::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::EnergySystematics::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1282_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::EnergySystematics::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1282_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::DU::EnergySystematics* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::DU::EnergySystematics(*(RAT::DU::EnergySystematics*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::EnergySystematics G__TRATcLcLDUcLcLEnergySystematics;
static int G__RAT_Dict_1282_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::EnergySystematics*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::EnergySystematics*) (soff+(sizeof(RAT::DU::EnergySystematics)*i)))->~G__TRATcLcLDUcLcLEnergySystematics();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::EnergySystematics*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::EnergySystematics*) (soff))->~G__TRATcLcLDUcLcLEnergySystematics();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1282_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::EnergySystematics* dest = (RAT::DU::EnergySystematics*) G__getstructoffset();
   *dest = *(RAT::DU::EnergySystematics*) libp->para[0].ref;
   const RAT::DU::EnergySystematics& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::DU::Point3D */
static int G__RAT_Dict_1283_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Point3D::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) RAT::DU::Point3D::GetSystemCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) RAT::DU::Point3D::HasZOffset((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::DU::Point3D::GetZOffset((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::DU::Point3D::GetSystemName((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::DU::Point3D::GetSystemDescription((const size_t) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) RAT::DU::Point3D::GetSystemId(*((const string*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Point3D::DumpSystemNames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Point3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::DU::Point3D((size_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RAT::DU::Point3D((size_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RAT::DU::Point3D[n];
       } else {
         p = new((void*) gvp) RAT::DU::Point3D[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RAT::DU::Point3D;
       } else {
         p = new((void*) gvp) RAT::DU::Point3D;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Point3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DU::Point3D(*(RAT::DU::Point3D*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RAT::DU::Point3D(*(RAT::DU::Point3D*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Point3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DU::Point3D((size_t) G__int(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RAT::DU::Point3D((size_t) G__int(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::DU::Point3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RAT::DU::Point3D(
(size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) RAT::DU::Point3D(
(size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->SetX((size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->SetY((size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->SetZ((size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->SetXYZ((size_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->SetCoordinateSystem((size_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((RAT::DU::Point3D*) G__getstructoffset())->operator=(*(RAT::DU::Point3D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const RAT::DU::Point3D*) G__getstructoffset())->GetCoordinateSystem());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->X());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Y());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->operator()((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->operator[]((const size_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->CosTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->CosPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->SinPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::DU::Point3D*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const RAT::DU::Point3D*) G__getstructoffset())->IsEquivalentTo(*(RAT::DU::Point3D*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const RAT::DU::Point3D*) G__getstructoffset())->IsEquivalentTo(*(RAT::DU::Point3D*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D* pobj;
         const RAT::DU::Point3D xobj = ((const RAT::DU::Point3D*) G__getstructoffset())->Reflection();
         pobj = new RAT::DU::Point3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const RAT::DU::Point3D*) G__getstructoffset())->GetDirectionFrom(*(RAT::DU::Point3D*) libp->para[0].ref);
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D* pobj;
         const RAT::DU::Point3D xobj = ((const RAT::DU::Point3D*) G__getstructoffset())->GetNewPoint(*(TVector3*) libp->para[0].ref);
         pobj = new RAT::DU::Point3D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((RAT::DU::Point3D*) G__getstructoffset())->Move(*(TVector3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((RAT::DU::Point3D*) G__getstructoffset())->operator+=(*(TVector3*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((RAT::DU::Point3D*) G__getstructoffset())->Midpoint(*(RAT::DU::Point3D*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RAT::DU::Point3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Point3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RAT::DU::Point3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::DU::Point3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RAT::DU::Point3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Point3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Point3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RAT::DU::Point3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1283_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RAT::DU::Point3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::DU::Point3D G__TRATcLcLDUcLcLPoint3D;
static int G__RAT_Dict_1283_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::DU::Point3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::DU::Point3D*) (soff+(sizeof(RAT::DU::Point3D)*i)))->~G__TRATcLcLDUcLcLPoint3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::DU::Point3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::DU::Point3D*) (soff))->~G__TRATcLcLDUcLcLPoint3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::LP::LightPath */
static int G__RAT_Dict_1285_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPath::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPath::GetRI((const RAT::LP::LightPath::RegionType) G__int(libp->para[0]), (const Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPath* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPath[n];
     } else {
       p = new((void*) gvp) RAT::LP::LightPath[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPath;
     } else {
       p = new((void*) gvp) RAT::LP::LightPath;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPath* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPath(
(Double_t) G__double(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref
, *(RAT::DU::Point3D*) libp->para[2].ref, (const RAT::LP::LightPath::RegionType) G__int(libp->para[3])
, (const RAT::LP::LightPath::RegionType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RAT::LP::LightPath(
(Double_t) G__double(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref
, *(RAT::DU::Point3D*) libp->para[2].ref, (const RAT::LP::LightPath::RegionType) G__int(libp->para[3])
, (const RAT::LP::LightPath::RegionType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPath(
(Double_t) G__double(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref
, *(RAT::DU::Point3D*) libp->para[2].ref, (const RAT::LP::LightPath::RegionType) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RAT::LP::LightPath(
(Double_t) G__double(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref
, *(RAT::DU::Point3D*) libp->para[2].ref, (const RAT::LP::LightPath::RegionType) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RAT::LP::LightPath*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetFitter();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->SetFitter(*((const string*) G__int(libp->para[0])));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->SetEnergy((Double_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RAT::LP::LightPath*) G__getstructoffset())->GetPointCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetPoint((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3& obj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetDirection((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RAT::LP::LightPath*) G__getstructoffset())->GetRegionType((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DU::Point3D& obj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetEndPos();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3& obj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetIncidentVecOnPMT();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3& obj = ((const RAT::LP::LightPath*) G__getstructoffset())->GetInitialLightVec();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->Reset();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->ClearPoints((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->AddPoint(*(RAT::DU::Point3D*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (RAT::LP::LightPath::RegionType) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->SetPoint((UInt_t) G__int(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->SetRegionType((UInt_t) G__int(libp->para[0]), (RAT::LP::LightPath::RegionType) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->InsertPoint((UInt_t) G__int(libp->para[0]), *(RAT::DU::Point3D*) libp->para[1].ref
, (RAT::LP::LightPath::RegionType) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((RAT::LP::LightPath*) G__getstructoffset())->DeletePoint((UInt_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetTotalDist());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetDist((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetDistByRegionType((RAT::LP::LightPath::RegionType) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetTotalTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1285_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPath*) G__getstructoffset())->GetCosThetaPMT((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1285_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::LP::LightPath* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::LP::LightPath(*(RAT::LP::LightPath*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::LP::LightPath G__TRATcLcLLPcLcLLightPath;
static int G__RAT_Dict_1285_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::LP::LightPath*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::LP::LightPath*) (soff+(sizeof(RAT::LP::LightPath)*i)))->~G__TRATcLcLLPcLcLLightPath();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::LP::LightPath*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::LP::LightPath*) (soff))->~G__TRATcLcLLPcLcLLightPath();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1285_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPath* dest = (RAT::LP::LightPath*) G__getstructoffset();
   *dest = *(RAT::LP::LightPath*) libp->para[0].ref;
   const RAT::LP::LightPath& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::LP::LightPathFitter */
static int G__RAT_Dict_1295_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::LP::LightPath& obj = ((const RAT::LP::LightPathFitter*) G__getstructoffset())->Fit(*(RAT::LP::LightPath*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1295_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RAT::LP::LightPathFitter*) G__getstructoffset())->GetSolidAngle(*(RAT::LP::LightPath*) libp->para[0].ref, *(TVector3*) libp->para[1].ref
, (UInt_t) G__int(libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::LP::LightPathFitter G__TRATcLcLLPcLcLLightPathFitter;
static int G__RAT_Dict_1295_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::LP::LightPathFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::LP::LightPathFitter*) (soff+(sizeof(RAT::LP::LightPathFitter)*i)))->~G__TRATcLcLLPcLcLLightPathFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::LP::LightPathFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::LP::LightPathFitter*) (soff))->~G__TRATcLcLLPcLcLLightPathFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1295_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathFitter* dest = (RAT::LP::LightPathFitter*) G__getstructoffset();
   *dest = *(RAT::LP::LightPathFitter*) libp->para[0].ref;
   const RAT::LP::LightPathFitter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::LP::LightPathStraightFitter */
static int G__RAT_Dict_1296_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPathStraightFitter::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetNeckInnerRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetNeckOuterRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetAVInnerRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetAVOuterRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetPMTRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RAT::LP::LightPathStraightFitter::GetFillZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::LP::LightPathStraightFitter::Name();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1296_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightFitter[n];
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightFitter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightFitter;
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightFitter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1296_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::LP::LightPathStraightFitter* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::LP::LightPathStraightFitter(*(RAT::LP::LightPathStraightFitter*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::LP::LightPathStraightFitter G__TRATcLcLLPcLcLLightPathStraightFitter;
static int G__RAT_Dict_1296_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::LP::LightPathStraightFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::LP::LightPathStraightFitter*) (soff+(sizeof(RAT::LP::LightPathStraightFitter)*i)))->~G__TRATcLcLLPcLcLLightPathStraightFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::LP::LightPathStraightFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::LP::LightPathStraightFitter*) (soff))->~G__TRATcLcLLPcLcLLightPathStraightFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1296_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightFitter* dest = (RAT::LP::LightPathStraightFitter*) G__getstructoffset();
   *dest = *(RAT::LP::LightPathStraightFitter*) libp->para[0].ref;
   const RAT::LP::LightPathStraightFitter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::LP::LightPathStraightScint */
static int G__RAT_Dict_1297_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPathStraightScint::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1297_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::LP::LightPathStraightScint::Name();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1297_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightScint* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightScint[n];
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightScint[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightScint;
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightScint;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1297_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPathStraightScint::GetPath(*((TVector3*) G__int(libp->para[0])), *((TVector3*) G__int(libp->para[1]))
, *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1297_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::LP::LightPathStraightScint* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::LP::LightPathStraightScint(*(RAT::LP::LightPathStraightScint*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::LP::LightPathStraightScint G__TRATcLcLLPcLcLLightPathStraightScint;
static int G__RAT_Dict_1297_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::LP::LightPathStraightScint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::LP::LightPathStraightScint*) (soff+(sizeof(RAT::LP::LightPathStraightScint)*i)))->~G__TRATcLcLLPcLcLLightPathStraightScint();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::LP::LightPathStraightScint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::LP::LightPathStraightScint*) (soff))->~G__TRATcLcLLPcLcLLightPathStraightScint();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1297_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightScint* dest = (RAT::LP::LightPathStraightScint*) G__getstructoffset();
   *dest = *(RAT::LP::LightPathStraightScint*) libp->para[0].ref;
   const RAT::LP::LightPathStraightScint& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RAT::LP::LightPathStraightScintWater */
static int G__RAT_Dict_1298_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPathStraightScintWater::BeginOfRun();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1298_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = RAT::LP::LightPathStraightScintWater::Name();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1298_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightScintWater* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightScintWater[n];
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightScintWater[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RAT::LP::LightPathStraightScintWater;
     } else {
       p = new((void*) gvp) RAT::LP::LightPathStraightScintWater;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1298_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RAT::LP::LightPathStraightScintWater::GetPath(*((TVector3*) G__int(libp->para[0])), *((TVector3*) G__int(libp->para[1]))
, *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__RAT_Dict_1298_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RAT::LP::LightPathStraightScintWater* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RAT::LP::LightPathStraightScintWater(*(RAT::LP::LightPathStraightScintWater*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RAT::LP::LightPathStraightScintWater G__TRATcLcLLPcLcLLightPathStraightScintWater;
static int G__RAT_Dict_1298_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RAT::LP::LightPathStraightScintWater*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RAT::LP::LightPathStraightScintWater*) (soff+(sizeof(RAT::LP::LightPathStraightScintWater)*i)))->~G__TRATcLcLLPcLcLLightPathStraightScintWater();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RAT::LP::LightPathStraightScintWater*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RAT::LP::LightPathStraightScintWater*) (soff))->~G__TRATcLcLLPcLcLLightPathStraightScintWater();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__RAT_Dict_1298_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RAT::LP::LightPathStraightScintWater* dest = (RAT::LP::LightPathStraightScintWater*) G__getstructoffset();
   *dest = *(RAT::LP::LightPathStraightScintWater*) libp->para[0].ref;
   const RAT::LP::LightPathStraightScintWater& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* map<string,string,less<string>,allocator<pair<const string,string> > > */
static int G__RAT_Dict_1301_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<string,string,less<string>,allocator<pair<const string,string> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<string,string,less<string>,allocator<pair<const string,string> > >[n];
     } else {
       p = new((void*) gvp) map<string,string,less<string>,allocator<pair<const string,string> > >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new map<string,string,less<string>,allocator<pair<const string,string> > >;
     } else {
       p = new((void*) gvp) map<string,string,less<string>,allocator<pair<const string,string> > >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<string,string,less<string>,allocator<pair<const string,string> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<string,string,less<string>,allocator<pair<const string,string> > >(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<string,string,less<string>,allocator<pair<const string,string> > >(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<string,string,less<string>,allocator<pair<const string,string> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<string,string,less<string>,allocator<pair<const string,string> > >(*((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) map<string,string,less<string>,allocator<pair<const string,string> > >(*((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   map<string,string,less<string>,allocator<pair<const string,string> > >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new map<string,string,less<string>,allocator<pair<const string,string> > >(*(map<string,string,less<string>,allocator<pair<const string,string> > >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) map<string,string,less<string>,allocator<pair<const string,string> > >(*(map<string,string,less<string>,allocator<pair<const string,string> > >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const map<string,string,less<string>,allocator<pair<const string,string> > >& obj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->operator=(*(map<string,string,less<string>,allocator<pair<const string,string> > >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->begin();
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->end();
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->rbegin();
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->rend();
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->operator[](*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<map<string,string,less<string>,allocator<pair<const string,string> > >::iterator,bool>* pobj;
         pair<map<string,string,less<string>,allocator<pair<const string,string> > >::iterator,bool> xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->insert(*(map<string,string,less<string>,allocator<pair<const string,string> > >::value_type*) libp->para[0].ref);
         pobj = new pair<map<string,string,less<string>,allocator<pair<const string,string> > >::iterator,bool>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->insert(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])), *(map<string,string,less<string>,allocator<pair<const string,string> > >::value_type*) libp->para[1].ref);
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->insert(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->insert(*((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->erase(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->erase(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->erase(*((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[0])), *((map<string,string,less<string>,allocator<pair<const string,string> > >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->swap(*(map<string,string,less<string>,allocator<pair<const string,string> > >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->find(*(string*) libp->para[0].ref);
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->count(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->lower_bound(*(string*) libp->para[0].ref);
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1301_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator* pobj;
         map<string,string,less<string>,allocator<pair<const string,string> > >::iterator xobj = ((map<string,string,less<string>,allocator<pair<const string,string> > >*) G__getstructoffset())->upper_bound(*(string*) libp->para[0].ref);
         pobj = new map<string,string,less<string>,allocator<pair<const string,string> > >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef map<string,string,less<string>,allocator<pair<const string,string> > > G__TmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR;
static int G__RAT_Dict_1301_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (map<string,string,less<string>,allocator<pair<const string,string> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((map<string,string,less<string>,allocator<pair<const string,string> > >*) (soff+(sizeof(map<string,string,less<string>,allocator<pair<const string,string> > >)*i)))->~G__TmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (map<string,string,less<string>,allocator<pair<const string,string> > >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((map<string,string,less<string>,allocator<pair<const string,string> > >*) (soff))->~G__TmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::TrackNode,allocator<RAT::TrackNode> > */
static int G__RAT_Dict_1306_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reference obj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->at((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_reference obj = ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->at((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator* pobj;
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator xobj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator* pobj;
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator xobj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator* pobj;
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator xobj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator* pobj;
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator xobj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->resize((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->resize((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]), *((RAT::TrackNode*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reference obj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->operator[]((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_reference obj = ((const vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->operator[]((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode,allocator<RAT::TrackNode> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >;
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode,allocator<RAT::TrackNode> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]), *(RAT::TrackNode*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]), *(RAT::TrackNode*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode,allocator<RAT::TrackNode> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >(*(vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >(*(vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::TrackNode,allocator<RAT::TrackNode> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::TrackNode,allocator<RAT::TrackNode> >(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::TrackNode,allocator<RAT::TrackNode> >& obj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->operator=(*(vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->reserve((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::TrackNode& obj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::TrackNode& obj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->push_back(*(RAT::TrackNode*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->swap(*(vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator* pobj;
         vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator xobj = ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[0])), *(RAT::TrackNode*) libp->para[1].ref);
         pobj = new vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->insert(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[0])), (vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type) G__int(libp->para[1])
, *(RAT::TrackNode*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->erase(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->erase(*((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[0])), *((vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1306_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::TrackNode,allocator<RAT::TrackNode> > G__TvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR;
static int G__RAT_Dict_1306_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) (soff+(sizeof(vector<RAT::TrackNode,allocator<RAT::TrackNode> >)*i)))->~G__TvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::TrackNode,allocator<RAT::TrackNode> >*) (soff))->~G__TvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<RAT::DBTable,allocator<RAT::DBTable> > */
static int G__RAT_Dict_1310_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reference obj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->at((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::const_reference obj = ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->at((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator* pobj;
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator xobj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->begin();
         pobj = new vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator* pobj;
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator xobj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->end();
         pobj = new vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator* pobj;
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator xobj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->rbegin();
         pobj = new vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator* pobj;
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator xobj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->rend();
         pobj = new vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->resize((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->resize((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]), *((RAT::DBTable*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::reference obj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->operator[]((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::const_reference obj = ((const vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->operator[]((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable,allocator<RAT::DBTable> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable,allocator<RAT::DBTable> >[n];
     } else {
       p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable,allocator<RAT::DBTable> >;
     } else {
       p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable,allocator<RAT::DBTable> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable,allocator<RAT::DBTable> >((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]), *(RAT::DBTable*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]), *(RAT::DBTable*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<RAT::DBTable,allocator<RAT::DBTable> >((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable,allocator<RAT::DBTable> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DBTable,allocator<RAT::DBTable> >(*(vector<RAT::DBTable,allocator<RAT::DBTable> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >(*(vector<RAT::DBTable,allocator<RAT::DBTable> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<RAT::DBTable,allocator<RAT::DBTable> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<RAT::DBTable,allocator<RAT::DBTable> >(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<RAT::DBTable,allocator<RAT::DBTable> >(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<RAT::DBTable,allocator<RAT::DBTable> >& obj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->operator=(*(vector<RAT::DBTable,allocator<RAT::DBTable> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->reserve((vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBTable& obj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RAT::DBTable& obj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->push_back(*(RAT::DBTable*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->swap(*(vector<RAT::DBTable,allocator<RAT::DBTable> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator* pobj;
         vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator xobj = ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[0])), *(RAT::DBTable*) libp->para[1].ref);
         pobj = new vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[1]))
, *((vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->insert(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[0])), (vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type) G__int(libp->para[1])
, *(RAT::DBTable*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->erase(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->erase(*((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[0])), *((vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__RAT_Dict_1310_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<RAT::DBTable,allocator<RAT::DBTable> > G__TvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR;
static int G__RAT_Dict_1310_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<RAT::DBTable,allocator<RAT::DBTable> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) (soff+(sizeof(vector<RAT::DBTable,allocator<RAT::DBTable> >)*i)))->~G__TvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<RAT::DBTable,allocator<RAT::DBTable> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<RAT::DBTable,allocator<RAT::DBTable> >*) (soff))->~G__TvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__RAT_Dict__0_6876(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) util_to_int(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) util_to_int(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* RAT */

/* RAT::DS::BitMask */

/* RAT::DS::Calib */

/* RAT::DS::DataNotFound */

/* RAT::DS::ClassifierResult */

/* RAT::DS::DataQCFlags */

/* map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > */

/* pair<unsigned int,RAT::DS::BitMask> */

/* RAT::DS::Digitiser */

/* RAT::DS::ECAHeader */

/* RAT::DS::UniversalTime */

/* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */

/* ROOT::Math::Cartesian3D<float> */

/* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */

/* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */

/* ROOT::Math::Polar3D<float> */

/* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */

/* RAT::DS::FitVertex */

/* RAT::DS::FitResult */

/* vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > */

/* RAT::DS::FitClassifierCollection<RAT::DS::FitResult> */

/* RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> */

/* json::Value */

/* RAT::Log */

/* RAT::BitManip */

/* RAT::DS::PMTCal */

/* RAT::DS::PMT<Double32_t> */

/* RAT::DS::PMT<unsigned short> */

/* RAT::DS::MCHit */

/* RAT::DU::PMTInfo */

/* RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > */

/* RAT::DS::PMTSet<RAT::DS::PMTCal> */

/* vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > */

/* RAT::DS::PMTSet<RAT::DS::MCHit> */

/* RAT::DS::EV */

/* map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > */

/* pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > */

/* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > */

/* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > */

/* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > */

/* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > */

/* RAT::DS::TrigHeader */

/* RAT::DS::HeaderInfo */

/* vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > */

/* vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > */

/* RAT::DS::MetaDB */

/* pair<string,string> */

/* RAT::DS::Run */

/* RAT::DS::Meta */

/* vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > */

/* RAT::DS::MCParticle */

/* RAT::DS::MCTrackStep */

/* RAT::DS::MCTrack */

/* vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > */

/* RAT::DS::MCPhoton */

/* RAT::DS::MCPE */

/* RAT::DS::MCPMT */

/* vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > */

/* vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > */

/* RAT::DS::MC */

/* vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > */

/* vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > */

/* vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > */

/* RAT::DS::MCEV */

/* RAT::DS::Entry */

/* vector<RAT::DS::MC,allocator<RAT::DS::MC> > */

/* vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > */

/* vector<RAT::DS::EV,allocator<RAT::DS::EV> > */

/* vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > */

/* RAT::DS::SOCPMT */

/* RAT::DS::SOC */

/* map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > */

/* pair<unsigned int,RAT::DS::SOCPMT> */

/* RAT::DU::DataCleaningBits */

/* RAT::DU::DataQualityBits */

/* RAT::DU::ChanSWStatus */

/* RAT::DU::TrigBits */

/* RAT::DU::DSReader */

/* RAT::DU::EffectiveVelocity */

/* RAT::DBTable */

/* RAT::DB */

/* RAT::DBLink */

/* RAT::PgSQLBackend */

/* simple_ptr_nocopy<RAT::DBTable> */

/* simple_ptr_nocopy<RAT::DBLink> */

/* vector<RAT::DBTable*,allocator<RAT::DBTable*> > */

/* RAT::DU::GroupVelocity */

/* RAT::DU::LightPathCalculator */

/* RAT::DU::PanelInfo */

/* RAT::DU::ChanHWStatus */

/* RAT::DU::PMTCalStatus */

/* RAT::DU::ReactorNuOsc */

/* RAT::DU::ShadowingCalculator */

/* RAT::DU::Segmentor */

/* RAT::DU::SOCReader */

/* RAT::DU::ReconCorrector */

/* RAT::DU::ReconCalibrator */

/* RAT::FitterPMT */

/* RAT::DU::TimeResidualCalculator */

/* RAT::DU::Utility */

/* RAT::TrackNode */

/* vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > */

/* RAT::TrackCursor */

/* RAT::TrackNav */

/* RAT::DBCommandLoader */

/* RAT::DBTextLoader */

/* RAT::DBJsonLoader */

/* RAT::HTTPDownloader */

/* RAT::MetaInformation */

/* PmtEventRecord */

/* RunRecord */

/* TriggerInfo */

/* EpedRecord */

/* ratzdab */

/* ratzdab::unpack */

/* ratzdab::pack */

/* ratzdab::unknown_record_error */

/* PZdabFile */

/* ratzdab::zdabfile */

/* ratzdab::zdabfile::zdab_file_read_error */

/* ManipRopeStatus */

/* MTCReadoutData */

/* RAT::util */

/* RAT::DU::EnergySystematics */

/* RAT::DU::Point3D */

/* RAT::LP::LightPath */

/* RAT::LP::LightPathFitter */

/* RAT::LP::LightPathStraightFitter */

/* RAT::LP::LightPathStraightScint */

/* RAT::LP::LightPathStraightScintWater */

/* map<string,string,less<string>,allocator<pair<const string,string> > > */

/* vector<RAT::TrackNode,allocator<RAT::TrackNode> > */

/* vector<RAT::DBTable,allocator<RAT::DBTable> > */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncRAT_Dict {
 public:
  G__Sizep2memfuncRAT_Dict(): p(&G__Sizep2memfuncRAT_Dict::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncRAT_Dict::*p)();
};

size_t G__get_sizep2memfuncRAT_Dict()
{
  G__Sizep2memfuncRAT_Dict a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceRAT_Dict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask))) {
     RAT::DS::BitMask *G__Lderived;
     G__Lderived=(RAT::DS::BitMask*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib))) {
     RAT::DS::Calib *G__Lderived;
     G__Lderived=(RAT::DS::Calib*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound))) {
     RAT::DS::DataNotFound *G__Lderived;
     G__Lderived=(RAT::DS::DataNotFound*)0x1000;
     {
       runtime_error *G__Lpbase=(runtime_error*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound),G__get_linked_tagnum(&G__RAT_DictLN_runtime_error),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       logic_error *G__Lpbase=(logic_error*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound),G__get_linked_tagnum(&G__RAT_DictLN_logic_error),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       exception *G__Lpbase=(exception*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound),G__get_linked_tagnum(&G__RAT_DictLN_exception),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult))) {
     RAT::DS::ClassifierResult *G__Lderived;
     G__Lderived=(RAT::DS::ClassifierResult*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags))) {
     RAT::DS::DataQCFlags *G__Lderived;
     G__Lderived=(RAT::DS::DataQCFlags*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser))) {
     RAT::DS::Digitiser *G__Lderived;
     G__Lderived=(RAT::DS::Digitiser*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader))) {
     RAT::DS::ECAHeader *G__Lderived;
     G__Lderived=(RAT::DS::ECAHeader*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime))) {
     RAT::DS::UniversalTime *G__Lderived;
     G__Lderived=(RAT::DS::UniversalTime*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex))) {
     RAT::DS::FitVertex *G__Lderived;
     G__Lderived=(RAT::DS::FitVertex*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult))) {
     RAT::DS::FitResult *G__Lderived;
     G__Lderived=(RAT::DS::FitResult*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR))) {
     RAT::DS::FitClassifierCollection<RAT::DS::FitResult> *G__Lderived;
     G__Lderived=(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR))) {
     RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> *G__Lderived;
     G__Lderived=(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal))) {
     RAT::DS::PMTCal *G__Lderived;
     G__Lderived=(RAT::DS::PMTCal*)0x1000;
     {
       RAT::DS::PMT<Double32_t> *G__Lpbase=(RAT::DS::PMT<Double32_t>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR))) {
     RAT::DS::PMT<Double32_t> *G__Lderived;
     G__Lderived=(RAT::DS::PMT<Double32_t>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR))) {
     RAT::DS::PMT<unsigned short> *G__Lderived;
     G__Lderived=(RAT::DS::PMT<unsigned short>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit))) {
     RAT::DS::MCHit *G__Lderived;
     G__Lderived=(RAT::DS::MCHit*)0x1000;
     {
       RAT::DS::PMT<Double32_t> *G__Lpbase=(RAT::DS::PMT<Double32_t>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo))) {
     RAT::DU::PMTInfo *G__Lderived;
     G__Lderived=(RAT::DU::PMTInfo*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR))) {
     RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > *G__Lderived;
     G__Lderived=(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR))) {
     RAT::DS::PMTSet<RAT::DS::PMTCal> *G__Lderived;
     G__Lderived=(RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR))) {
     RAT::DS::PMTSet<RAT::DS::MCHit> *G__Lderived;
     G__Lderived=(RAT::DS::PMTSet<RAT::DS::MCHit>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV))) {
     RAT::DS::EV *G__Lderived;
     G__Lderived=(RAT::DS::EV*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader))) {
     RAT::DS::TrigHeader *G__Lderived;
     G__Lderived=(RAT::DS::TrigHeader*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo))) {
     RAT::DS::HeaderInfo *G__Lderived;
     G__Lderived=(RAT::DS::HeaderInfo*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB))) {
     RAT::DS::MetaDB *G__Lderived;
     G__Lderived=(RAT::DS::MetaDB*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun))) {
     RAT::DS::Run *G__Lderived;
     G__Lderived=(RAT::DS::Run*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta))) {
     RAT::DS::Meta *G__Lderived;
     G__Lderived=(RAT::DS::Meta*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle))) {
     RAT::DS::MCParticle *G__Lderived;
     G__Lderived=(RAT::DS::MCParticle*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep))) {
     RAT::DS::MCTrackStep *G__Lderived;
     G__Lderived=(RAT::DS::MCTrackStep*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack))) {
     RAT::DS::MCTrack *G__Lderived;
     G__Lderived=(RAT::DS::MCTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton))) {
     RAT::DS::MCPhoton *G__Lderived;
     G__Lderived=(RAT::DS::MCPhoton*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE))) {
     RAT::DS::MCPE *G__Lderived;
     G__Lderived=(RAT::DS::MCPE*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT))) {
     RAT::DS::MCPMT *G__Lderived;
     G__Lderived=(RAT::DS::MCPMT*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC))) {
     RAT::DS::MC *G__Lderived;
     G__Lderived=(RAT::DS::MC*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV))) {
     RAT::DS::MCEV *G__Lderived;
     G__Lderived=(RAT::DS::MCEV*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry))) {
     RAT::DS::Entry *G__Lderived;
     G__Lderived=(RAT::DS::Entry*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT))) {
     RAT::DS::SOCPMT *G__Lderived;
     G__Lderived=(RAT::DS::SOCPMT*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC))) {
     RAT::DS::SOC *G__Lderived;
     G__Lderived=(RAT::DS::SOC*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits))) {
     RAT::DU::DataCleaningBits *G__Lderived;
     G__Lderived=(RAT::DU::DataCleaningBits*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits))) {
     RAT::DU::DataQualityBits *G__Lderived;
     G__Lderived=(RAT::DU::DataQualityBits*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus))) {
     RAT::DU::ChanSWStatus *G__Lderived;
     G__Lderived=(RAT::DU::ChanSWStatus*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits))) {
     RAT::DU::TrigBits *G__Lderived;
     G__Lderived=(RAT::DU::TrigBits*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader))) {
     RAT::DU::DSReader *G__Lderived;
     G__Lderived=(RAT::DU::DSReader*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity))) {
     RAT::DU::EffectiveVelocity *G__Lderived;
     G__Lderived=(RAT::DU::EffectiveVelocity*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity))) {
     RAT::DU::GroupVelocity *G__Lderived;
     G__Lderived=(RAT::DU::GroupVelocity*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator))) {
     RAT::DU::LightPathCalculator *G__Lderived;
     G__Lderived=(RAT::DU::LightPathCalculator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo))) {
     RAT::DU::PanelInfo *G__Lderived;
     G__Lderived=(RAT::DU::PanelInfo*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus))) {
     RAT::DU::ChanHWStatus *G__Lderived;
     G__Lderived=(RAT::DU::ChanHWStatus*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus))) {
     RAT::DU::PMTCalStatus *G__Lderived;
     G__Lderived=(RAT::DU::PMTCalStatus*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor))) {
     RAT::DU::Segmentor *G__Lderived;
     G__Lderived=(RAT::DU::Segmentor*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader))) {
     RAT::DU::SOCReader *G__Lderived;
     G__Lderived=(RAT::DU::SOCReader*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator))) {
     RAT::DU::TimeResidualCalculator *G__Lderived;
     G__Lderived=(RAT::DU::TimeResidualCalculator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility))) {
     RAT::DU::Utility *G__Lderived;
     G__Lderived=(RAT::DU::Utility*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode))) {
     RAT::TrackNode *G__Lderived;
     G__Lderived=(RAT::TrackNode*)0x1000;
     {
       RAT::DS::MCTrackStep *G__Lpbase=(RAT::DS::MCTrackStep*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error))) {
     ratzdab::unknown_record_error *G__Lderived;
     G__Lderived=(ratzdab::unknown_record_error*)0x1000;
     {
       exception *G__Lpbase=(exception*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error),G__get_linked_tagnum(&G__RAT_DictLN_exception),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error))) {
     ratzdab::zdabfile::zdab_file_read_error *G__Lderived;
     G__Lderived=(ratzdab::zdabfile::zdab_file_read_error*)0x1000;
     {
       exception *G__Lpbase=(exception*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error),G__get_linked_tagnum(&G__RAT_DictLN_exception),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics))) {
     RAT::DU::EnergySystematics *G__Lderived;
     G__Lderived=(RAT::DU::EnergySystematics*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D))) {
     RAT::DU::Point3D *G__Lderived;
     G__Lderived=(RAT::DU::Point3D*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),G__get_linked_tagnum(&G__RAT_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter))) {
     RAT::LP::LightPathStraightFitter *G__Lderived;
     G__Lderived=(RAT::LP::LightPathStraightFitter*)0x1000;
     {
       RAT::LP::LightPathFitter *G__Lpbase=(RAT::LP::LightPathFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint))) {
     RAT::LP::LightPathStraightScint *G__Lderived;
     G__Lderived=(RAT::LP::LightPathStraightScint*)0x1000;
     {
       RAT::LP::LightPathFitter *G__Lpbase=(RAT::LP::LightPathFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater))) {
     RAT::LP::LightPathStraightScintWater *G__Lderived;
     G__Lderived=(RAT::LP::LightPathStraightScintWater*)0x1000;
     {
       RAT::LP::LightPathFitter *G__Lpbase=(RAT::LP::LightPathFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater),G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableRAT_Dict() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UShort_t",114,-1,0,-1);
   G__setnewtype(-1,"Unsigned Short integer 2 bytes (unsigned short)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 8 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Double32_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes in memory, written as a 4 bytes float",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ULong64_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPlongsPlongcOallocatorlEunsignedsPlongsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,Double32_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,Double32_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,Double32_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,Double32_t,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,BitMask>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",104,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEunsignedsPintgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::BitMask>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::BitMask,less<unsigned int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UShort_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UShort_t,std::vector<UShort_t> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned short,vector<unsigned short,allocator<unsigned short> > >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned short,vector<unsigned short,allocator<unsigned short> >,less<unsigned short> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Cartesian3D<double>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Cartesian3D<float>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("XYZVectorF",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<CylindricalEta3D<double>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<CylindricalEta3D<float>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Polar3D<double>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Polar3D<float>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Polar3DVectorF",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Cylindrical3D<double>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DisplacementVector3D<Cylindrical3D<float>,DefaultCoordinateSystemTag>",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",102,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",102,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",100,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateType",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateSystemTag",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",102,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateType",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateSystemTag",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",100,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateType",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateSystemTag",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Scalar",102,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateType",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CoordinateSystemTag",117,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag),0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<FitVertex>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::FitVertex>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FitClassifierCollection<FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RAT::DS::FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::FitResult,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FitCollection",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,"/< typedef for collection of FitResults",0);
   G__search_typename2("FitClassifierCollection<ClassifierResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RAT::DS::ClassifierResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::ClassifierResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::ClassifierResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::ClassifierResult,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ClassifierCollection",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,"/< typedef for collection of ClassifierResults",0);
   G__search_typename2("vector<otext>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEotextcOallocatorlEotextgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEotextcOallocatorlEotextgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<itext>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEitextcOallocatorlEitextgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEitextcOallocatorlEitextgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TInteger",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TUInteger",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TReal",100,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TBool",103,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TString",117,G__get_linked_tagnum(&G__RAT_DictLN_string),0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Value>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,json::Value>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,json::Value,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TObject",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Value>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<json::Value>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TArray",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_json));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PMT<UShort_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PMTUncal",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVector3>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlETVector3cOallocatorlETVector3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlETVector3cOallocatorlETVector3gRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EPMTType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DU::PMTInfo::EPMTType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EPetalStatus>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DU::PMTInfo::EPetalStatus>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PMTSet<PMTUncal>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::PMT<unsigned short> >",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("UncalPMTs",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PMTSet<PMTCal>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::PMTCal>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("CalPMTs",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("PMTSet<MCHit>",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCHit>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MCHits",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,CalPMTs>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",104,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEunsignedsPintgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,FitCollection>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",104,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEunsignedsPintgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,ClassifierCollection>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",104,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEunsignedsPintgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Digitiser>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::Digitiser>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UShort_t,UShort_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned short,unsigned short>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned short,unsigned short,less<unsigned short> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ECAHeader>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::ECAHeader>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TrigHeader>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::TrigHeader>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<std::string,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<string,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<std::string,std::string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<string,std::string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<string,string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MetaDB>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MetaDB>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<size_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<unsigned long>",117,G__get_linked_tagnum(&G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<unsigned long,less<unsigned long> >",117,G__get_linked_tagnum(&G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCTrackStep>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCTrackStep>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCPhoton>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCPhoton>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCPE>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCPE>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCParticle>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCParticle>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCTrack>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCTrack>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MC>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MC>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MCEV>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::MCEV>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EV>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::EV>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<HeaderInfo>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DS::HeaderInfo>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,SOCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",104,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEunsignedsPintgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::SOCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,FitResult>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,SOC>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,SOC>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::SOC>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RAT::DS::SOC,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,size_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,size_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,unsigned long>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,unsigned long,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<size_t,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned long,string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned long,string,less<unsigned long> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<bool,unsigned>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEboolcOunsignedsPintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<hash<string,RAT::DBTable::FieldType,RAT::pyhash,equal_to<string> >::iterator,bool>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstlpluscLcLhash_iteratorlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRcOpairlEconstsPstringcORATcLcLDBTablecLcLFieldTypegRsPgRcOboolgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("simple_ptr_nocopy<DBTable>",117,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),0,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),1,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),257,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<DBTableKey,simple_ptr_nocopy<DBTable> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable>,less<RAT::DBTableKey> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DBTableSet",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("simple_ptr_nocopy<DBLink>",117,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink),0,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink),1,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink),257,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DBLinkPtr",117,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,DBLinkPtr>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,DBLinkPtr>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,simple_ptr_nocopy<RAT::DBLink> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,simple_ptr_nocopy<RAT::DBLink>,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("DBLinkGroup",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DBTable*>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DBTable*>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::pair<std::string,std::string>,int>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,std::string>,int>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,string>,int>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,string>,int,less<pair<string,string> > >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RAT::DBLink*>",117,G__get_linked_tagnum(&G__RAT_DictLN_listlERATcLcLDBLinkmUcOallocatorlERATcLcLDBLinkmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<string>",117,G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<RAT::DBTableKey>",117,G__get_linked_tagnum(&G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<RAT::DBTableKey,less<RAT::DBTableKey> >",117,G__get_linked_tagnum(&G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<RAT::DBTableKey>",117,G__get_linked_tagnum(&G__RAT_DictLN_dequelERATcLcLDBTableKeycOallocatorlERATcLcLDBTableKeygRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<eLightPathType,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RAT::DU::eLightPathType,string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RAT::DU::eLightPathType,string,less<RAT::DU::eLightPathType> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EPanelType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DU::PanelInfo::EPanelType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TrackNode*>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::TrackNode*>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("unary_function<TrackNode*,bool>",117,G__get_linked_tagnum(&G__RAT_DictLN_unary_functionlERATcLcLTrackNodemUcOboolgR),0,G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,TrackNode*>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,RAT::TrackNode*>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,RAT::TrackNode*,less<int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<RAT::Tokenizer>",117,G__get_linked_tagnum(&G__RAT_DictLN_dequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<Tokenizer>",117,G__get_linked_tagnum(&G__RAT_DictLN_stacklERATcLcLTokenizercOdequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<RAT::Tokenizer>",117,G__get_linked_tagnum(&G__RAT_DictLN_stacklERATcLcLTokenizercOdequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("uint32_t",104,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float,less<int> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("aPMTCal",117,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLPMTCal),0,G__get_linked_tagnum(&G__RAT_DictLN_ratzdab));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("nZDAB",117,G__get_linked_tagnum(&G__RAT_DictLN_nZDAB),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("complex<G4double>",117,G__get_linked_tagnum(&G__RAT_DictLN_complexlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("G4ThreeVector",117,G__get_linked_tagnum(&G__RAT_DictLN_CLHEPcLcLHep3Vector),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DU::Point3D>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RegionType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::LP::LightPath::RegionType>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,RAT::DS::BitMask>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RAT::DS::BitMask>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,RAT::DS::PMTSet<RAT::DS::PMTCal> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RAT::DS::PMTSet<RAT::DS::PMTCal> >",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<UInt_t,RAT::DS::SOCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,RAT::DS::SOCPMT>",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,std::string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",117,G__get_linked_tagnum(&G__RAT_DictLN_string),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("mapped_type",117,G__get_linked_tagnum(&G__RAT_DictLN_string),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__RAT_DictLN_lesslEstringgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__RAT_DictLN_allocatorlEpairlEconstsPstringcOstringgRsPgR),0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,string>",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,string,less<string> >",117,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::TrackNode>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RAT::DBTable>",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),1,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),257,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",107,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* RAT */
static void G__setup_memvarRAT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   {
   G__memvar_setup((void*)(&RAT::BLACK),67,0,5,-1,-1,-1,1,"BLACK=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BBLACK),67,0,5,-1,-1,-1,1,"BBLACK=",0,"bold black");
   G__memvar_setup((void*)(&RAT::RED),67,0,5,-1,-1,-1,1,"RED=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BRED),67,0,5,-1,-1,-1,1,"BRED=",0,"bold red");
   G__memvar_setup((void*)(&RAT::GREEN),67,0,5,-1,-1,-1,1,"GREEN=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BGREEN),67,0,5,-1,-1,-1,1,"BGREEN=",0,"bold green");
   G__memvar_setup((void*)(&RAT::YELLOW),67,0,5,-1,-1,-1,1,"YELLOW=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BYELLOW),67,0,5,-1,-1,-1,1,"BYELLOW=",0,"bold yellow");
   G__memvar_setup((void*)(&RAT::BLUE),67,0,5,-1,-1,-1,1,"BLUE=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BBLUE),67,0,5,-1,-1,-1,1,"BBLUE=",0,"bold blue");
   G__memvar_setup((void*)(&RAT::MAGENTA),67,0,5,-1,-1,-1,1,"MAGENTA=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BMAGENTA),67,0,5,-1,-1,-1,1,"BMAGENTA=",0,"bold magenta");
   G__memvar_setup((void*)(&RAT::CYAN),67,0,5,-1,-1,-1,1,"CYAN=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BCYAN),67,0,5,-1,-1,-1,1,"BCYAN=",0,"bold cyan");
   G__memvar_setup((void*)(&RAT::WHITE),67,0,5,-1,-1,-1,1,"WHITE=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::BWHITE),67,0,5,-1,-1,-1,1,"BWHITE=",0,"bold cyan");
   G__memvar_setup((void*)(&RAT::CLR),67,0,5,-1,-1,-1,1,"CLR=",0,"clear");
   G__memvar_setup((void*)(&RAT::warn),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_omtext),-1,-1,1,"warn=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::info),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_omtext),-1,-1,1,"info=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::detail),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_omtext),-1,-1,1,"detail=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::debug),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_omtext),-1,-1,1,"debug=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::RATVERSION),117,0,1,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"RATVERSION=",0,(char*)NULL);
   G__memvar_setup((void*)(&RAT::RATREVISION),117,0,1,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"RATREVISION=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::BitMask */
static void G__setup_memvarRATcLcLDScLcLBitMask(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask));
   { RAT::DS::BitMask *p; p=(RAT::DS::BitMask*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPlongsPlongcOallocatorlEunsignedsPlongsPlonggRsPgR),G__defined_typename("vector<ULong64_t>"),-1,2,"flags=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::Calib */
static void G__setup_memvarRATcLcLDScLcLCalib(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib));
   { RAT::DS::Calib *p; p=(RAT::DS::Calib*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"sourceName=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"id=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"mode=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"intensity=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"time=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,2,"pos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,2,"dir=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::DataNotFound */
static void G__setup_memvarRATcLcLDScLcLDataNotFound(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound));
   { RAT::DS::DataNotFound *p; p=(RAT::DS::DataNotFound*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fClassName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"fClassName=",0,"/< The name of the class that the variable belongs to");
   G__memvar_setup((void*)((long)(&p->fFieldName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"fFieldName=",0,"/< The name of the variable that cannot be accessed");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::ClassifierResult */
static void G__setup_memvarRATcLcLDScLcLClassifierResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult));
   { RAT::DS::ClassifierResult *p; p=(RAT::DS::ClassifierResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),G__defined_typename("map<std::string,Double32_t>"),-1,4,"classifications=",0,"/< Map between classification name and value");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),G__defined_typename("map<std::string,Double32_t>"),-1,4,"foms=",0,"/< Figure of merit mapping");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,4,"executionTime=",0,"/< Returns classifier execution time, for comparisons");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"valid=",0,"/< Is the classifier valid");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::DataQCFlags */
static void G__setup_memvarRATcLcLDScLcLDataQCFlags(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags));
   { RAT::DS::DataQCFlags *p; p=(RAT::DS::DataQCFlags*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),G__defined_typename("map<UInt_t,BitMask>"),-1,2,"flags=",0,"/< The flags indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),G__defined_typename("map<UInt_t,BitMask>"),-1,2,"applied=",0,"/< The applied flags indexed by pass");
   }
   G__tag_memvar_reset();
}


   /* map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > */
static void G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   { map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > *p; p=(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* pair<unsigned int,RAT::DS::BitMask> */
static void G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
   { pair<unsigned int,RAT::DS::BitMask> *p; p=(pair<unsigned int,RAT::DS::BitMask>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),104,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::Digitiser */
static void G__setup_memvarRATcLcLDScLcLDigitiser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser));
   { RAT::DS::Digitiser *p; p=(RAT::DS::Digitiser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR),G__defined_typename("map<UShort_t,std::vector<UShort_t> >"),-1,2,"waveforms=",0,"/< Map of input number to samples");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"eventID=",0,"/< The event Global Trigger ID, GTID, as understood by the digitiser");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"trigTime=",0,"/< The trigger time on the digitiser");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nWords=",0,"/< Number of 32bit words in each waveform");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"boardID=",0,"/< The board VME ID");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"bit24=",0,"/< Input header bit 24");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"dataFormat=",0,"/< The data format type");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"ioPins=",0,"/< Front panel IO pins");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"chanMask=",0,"/< Current channel mask");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::ECAHeader */
static void G__setup_memvarRATcLcLDScLcLECAHeader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader));
   { RAT::DS::ECAHeader *p; p=(RAT::DS::ECAHeader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"gtDelayCoarse=",0,"/< Coarse delay between pedestal and global trigger");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"gtDelayFine=",0,"/< Fine delay between pedestal and global trigger");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"chargePedestalAmplitude=",0,"/< Amplitude of charge pedestal");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"chargePedestalWidth=",0,"/< Width of charge pedestal");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"patternID=",0,"/< ECA pattern ID");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"calType=",0,"/< Type of calibration");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nTSlopePoints=",0,"/< The number of TSlope points");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"flag=",0,"/< Calibration status: 1->Start, 2->Change in inj value, 3->End of calib, 4->End of run");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::UniversalTime */
static void G__setup_memvarRATcLcLDScLcLUniversalTime(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime));
   { RAT::DS::UniversalTime *p; p=(RAT::DS::UniversalTime*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"days=",0,"/< Universal time i.e. relative to the world (days since SNO+ day0)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"seconds=",0,"/< Universal time i.e. relative to the world (secs)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"nanoSeconds=",0,"/< Universal time i.e. relative to the world (nsecs)");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
static void G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   { ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> *p; p=(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR),-1,-1,4,"fCoordinates=",0,"internal coordinate system");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::Cartesian3D<float> */
static void G__setup_memvarROOTcLcLMathcLcLCartesian3DlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   { ROOT::Math::Cartesian3D<float> *p; p=(ROOT::Math::Cartesian3D<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fX=",0,"x coordinate");
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fY=",0,"y coordinate");
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fZ=",0,"z coordinate");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
static void G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   { ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> *p; p=(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR),-1,-1,4,"fCoordinates=",0,"internal coordinate system");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
static void G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   { ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> *p; p=(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR),-1,-1,4,"fCoordinates=",0,"internal coordinate system");
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::Polar3D<float> */
static void G__setup_memvarROOTcLcLMathcLcLPolar3DlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   { ROOT::Math::Polar3D<float> *p; p=(ROOT::Math::Polar3D<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fR=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"fPhi=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
static void G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   { ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> *p; p=(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR),-1,-1,4,"fCoordinates=",0,"internal coordinate system");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::FitVertex */
static void G__setup_memvarRATcLcLDScLcLFitVertex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex));
   { RAT::DS::FitVertex *p; p=(RAT::DS::FitVertex*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("ePosition=%lldLL",(long long)RAT::DS::FitVertex::ePosition).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("ePositivePositionError=%lldLL",(long long)RAT::DS::FitVertex::ePositivePositionError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eNegativePositionError=%lldLL",(long long)RAT::DS::FitVertex::eNegativePositionError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eDirection=%lldLL",(long long)RAT::DS::FitVertex::eDirection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("ePositiveDirectionError=%lldLL",(long long)RAT::DS::FitVertex::ePositiveDirectionError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eNegativeDirectionError=%lldLL",(long long)RAT::DS::FitVertex::eNegativeDirectionError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eEnergy=%lldLL",(long long)RAT::DS::FitVertex::eEnergy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("ePositiveEnergyError=%lldLL",(long long)RAT::DS::FitVertex::ePositiveEnergyError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eNegativeEnergyError=%lldLL",(long long)RAT::DS::FitVertex::eNegativeEnergyError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eTime=%lldLL",(long long)RAT::DS::FitVertex::eTime).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("ePositiveTimeError=%lldLL",(long long)RAT::DS::FitVertex::ePositiveTimeError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues),-1,-2,1,G__FastAllocString(2048).Format("eNegativeTimeError=%lldLL",(long long)RAT::DS::FitVertex::eNegativeTimeError).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"position=",0,"/< Position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"positivePositionError=",0,"/< Position Errors along the positive coordinate axes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"negativePositionError=",0,"/< Position Errors along the negative coordinate axes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"direction=",0,"/< Direction");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"positiveDirectionError=",0,"/< Direction Error along the positive coordinate axes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,4,"negativeDirectionError=",0,"/< Direction Error along the negative coordinate axes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,4,"energy=",0,"/< Energy");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,4,"positiveEnergyError=",0,"/< Positive energy error");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,4,"negativeEnergyError=",0,"/< Negative energy error");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"time=",0,"/< Fit time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"positiveTimeError=",0,"/< Fit positive time error");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"negativeTimeError=",0,"/< Fit negative time error");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"dataMask=",0,"/< States what data exists in this fit result");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"validMask=",0,"/< States what data is valid");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fixedMask=",0,"/< States which parameters were fixed by the fitter (i.e. False implies these were calculated by the fitter)");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::FitResult */
static void G__setup_memvarRATcLcLDScLcLFitResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult));
   { RAT::DS::FitResult *p; p=(RAT::DS::FitResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR),G__defined_typename("map<std::string,Double32_t>"),-1,4,"foms=",0,"/< Figure of merit mapping");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR),G__defined_typename("vector<FitVertex>"),-1,4,"vertices=",0,"/< Fit Vertices i.e. position, time etc...");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,4,"executionTime=",0,"/< Returns fit execution time, for comparisons");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > */
static void G__setup_memvarvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   { vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > *p; p=(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::FitClassifierCollection<RAT::DS::FitResult> */
static void G__setup_memvarRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR));
   { RAT::DS::FitClassifierCollection<RAT::DS::FitResult> *p; p=(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),G__defined_typename("map<std::string,RAT::DS::FitResult>"),-1,2,"results=",0,"/< map results, indexed by name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> */
static void G__setup_memvarRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR));
   { RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> *p; p=(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR),G__defined_typename("map<std::string,RAT::DS::ClassifierResult>"),-1,2,"results=",0,"/< map results, indexed by name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* json::Value */
static void G__setup_memvarjsoncLcLValue(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   { json::Value *p; p=(json::Value*)0x1000; if (p) { }
   G__memvar_setup((void*)0,75,0,0,-1,G__defined_typename("TUInteger"),-1,2,"refcount=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLType),-1,-1,2,"type=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLTData),G__defined_typename("TData"),-1,2,"data=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::Log */
static void G__setup_memvarRATcLcLLog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog));
   { RAT::Log *p; p=(RAT::Log*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLogcLcLLevel),-1,-2,1,G__FastAllocString(2048).Format("WARN=%lldLL",(long long)RAT::Log::WARN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLogcLcLLevel),-1,-2,1,G__FastAllocString(2048).Format("INFO=%lldLL",(long long)RAT::Log::INFO).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLogcLcLLevel),-1,-2,1,G__FastAllocString(2048).Format("DETAIL=%lldLL",(long long)RAT::Log::DETAIL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLogcLcLLevel),-1,-2,1,G__FastAllocString(2048).Format("DEBUG=%lldLL",(long long)RAT::Log::DEBUG).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_omtext),-1,-2,2,"outstreams[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-2,2,"filename=",0,"Name of log file. */");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_oftext),-1,-2,2,"logfile=",0,"Log file object */");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,2,"display_level=",0,"Current display verbosity */");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,2,"log_level=",0,"Current log file verbosity */");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-2,2,"macro=",0,"Buffer of macro commands run so far */");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-2,2,"enable_dbtrace=",0,"Enable RATDB tracing? */");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TMap),-1,-2,2,"dbtrace=",0,"Record of all accessed RATDB fields */");
   }
   G__tag_memvar_reset();
}


   /* RAT::BitManip */
static void G__setup_memvarRATcLcLBitManip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip));
   { RAT::BitManip *p; p=(RAT::BitManip*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMTCal */
static void G__setup_memvarRATcLcLDScLcLPMTCal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal));
   { RAT::DS::PMTCal *p; p=(RAT::DS::PMTCal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),-1,-1,2,"status=",0,"/< Status flags for the various calibrations");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMT<Double32_t> */
static void G__setup_memvarRATcLcLDScLcLPMTlEDouble32_tgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR));
   { RAT::DS::PMT<Double32_t> *p; p=(RAT::DS::PMT<Double32_t>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"id=",0,"/< PMT ID, i.e. logical channel number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"qhs=",0,"/< Charge: high gain, short integration time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"qhl=",0,"/< Charge: high gain, long integration time");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"qlx=",0,"/< Charge: low gain charge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"time=",0,"/< Hit time");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"cellID=",0,"/< Cell number in electronics");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"chanFlags=",0,"/< Electronics errors/settings");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"isCrossTalk=",0,"/< True if this hit is cause by crosstalk");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMT<unsigned short> */
static void G__setup_memvarRATcLcLDScLcLPMTlEunsignedsPshortgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR));
   { RAT::DS::PMT<unsigned short> *p; p=(RAT::DS::PMT<unsigned short>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"id=",0,"/< PMT ID, i.e. logical channel number");
   G__memvar_setup((void*)0,114,0,0,-1,-1,-1,2,"qhs=",0,"/< Charge: high gain, short integration time");
   G__memvar_setup((void*)0,114,0,0,-1,-1,-1,2,"qhl=",0,"/< Charge: high gain, long integration time");
   G__memvar_setup((void*)0,114,0,0,-1,-1,-1,2,"qlx=",0,"/< Charge: low gain charge");
   G__memvar_setup((void*)0,114,0,0,-1,-1,-1,2,"time=",0,"/< Hit time");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"cellID=",0,"/< Cell number in electronics");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"chanFlags=",0,"/< Electronics errors/settings");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"isCrossTalk=",0,"/< True if this hit is cause by crosstalk");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCHit */
static void G__setup_memvarRATcLcLDScLcLMCHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit));
   { RAT::DS::MCHit *p; p=(RAT::DS::MCHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::PMTInfo */
static void G__setup_memvarRATcLcLDUcLcLPMTInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo));
   { RAT::DU::PMTInfo *p; p=(RAT::DU::PMTInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("NORMAL=%lldLL",(long long)RAT::DU::PMTInfo::NORMAL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("OWL=%lldLL",(long long)RAT::DU::PMTInfo::OWL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("LOWGAIN=%lldLL",(long long)RAT::DU::PMTInfo::LOWGAIN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("BUTT=%lldLL",(long long)RAT::DU::PMTInfo::BUTT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("NECK=%lldLL",(long long)RAT::DU::PMTInfo::NECK).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("CALIB=%lldLL",(long long)RAT::DU::PMTInfo::CALIB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("HQE=%lldLL",(long long)RAT::DU::PMTInfo::HQE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("SPARE=%lldLL",(long long)RAT::DU::PMTInfo::SPARE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType),-1,-2,1,G__FastAllocString(2048).Format("INVALID=%lldLL",(long long)RAT::DU::PMTInfo::INVALID).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus),-1,-2,1,G__FastAllocString(2048).Format("STANDARD=%lldLL",(long long)RAT::DU::PMTInfo::STANDARD).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus),-1,-2,1,G__FastAllocString(2048).Format("NONE=%lldLL",(long long)RAT::DU::PMTInfo::NONE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus),-1,-2,1,G__FastAllocString(2048).Format("UNAVAILABLE=%lldLL",(long long)RAT::DU::PMTInfo::UNAVAILABLE).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fPositions=",0,"/< The PMT positions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fDirections=",0,"/< The PMT Directions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR),G__defined_typename("vector<EPMTType>"),-1,4,"fTypes=",0,"/< The pmt types");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR),G__defined_typename("vector<EPetalStatus>"),-1,4,"fPetalStatus=",0,"/< The petal status types");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fPanels=",0,"/< The pmt panel numbers");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > */
static void G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR));
   { RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > *p; p=(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"normal=",0,"/< Collection of normal PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"inward=",0,"/< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"owl=",0,"/< Collection of OWL PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"lowGain=",0,"/< Collection of Low Gain PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"butt=",0,"/< Collection of BUTT PMTs (don't exist in SNO+)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"neck=",0,"/< Collection of neck PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"fecd=",0,"/< Collection of FECD PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"spare=",0,"/< Collection of spare PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"hqe=",0,"/< Collection of HQE PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR),G__defined_typename("vector<RAT::DS::PMT<unsigned short> >"),-1,2,"invalid=",0,"/< Collection of invalid PMTs (really daq channels)");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMTSet<RAT::DS::PMTCal> */
static void G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR));
   { RAT::DS::PMTSet<RAT::DS::PMTCal> *p; p=(RAT::DS::PMTSet<RAT::DS::PMTCal>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"normal=",0,"/< Collection of normal PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"inward=",0,"/< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"owl=",0,"/< Collection of OWL PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"lowGain=",0,"/< Collection of Low Gain PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"butt=",0,"/< Collection of BUTT PMTs (don't exist in SNO+)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"neck=",0,"/< Collection of neck PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"fecd=",0,"/< Collection of FECD PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"spare=",0,"/< Collection of spare PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"hqe=",0,"/< Collection of HQE PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),G__defined_typename("vector<RAT::DS::PMTCal>"),-1,2,"invalid=",0,"/< Collection of invalid PMTs (really daq channels)");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > */
static void G__setup_memvarvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   { vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > *p; p=(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::PMTSet<RAT::DS::MCHit> */
static void G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR));
   { RAT::DS::PMTSet<RAT::DS::MCHit> *p; p=(RAT::DS::PMTSet<RAT::DS::MCHit>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"normal=",0,"/< Collection of normal PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"inward=",0,"/< Collection of inward PMTs (normal + HQE)- keeping to be able to prune old files");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"owl=",0,"/< Collection of OWL PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"lowGain=",0,"/< Collection of Low Gain PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"butt=",0,"/< Collection of BUTT PMTs (don't exist in SNO+)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"neck=",0,"/< Collection of neck PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"fecd=",0,"/< Collection of FECD PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"spare=",0,"/< Collection of spare PMTs (really daq channels)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"hqe=",0,"/< Collection of HQE PMTs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR),G__defined_typename("vector<RAT::DS::MCHit>"),-1,2,"invalid=",0,"/< Collection of invalid PMTs (really daq channels)");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::EV */
static void G__setup_memvarRATcLcLDScLcLEV(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV));
   { RAT::DS::EV *p; p=(RAT::DS::EV*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime),-1,-1,2,"universalTime=",0,"/< Universal time of the event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags),-1,-1,2,"dataCleaningFlags=",0,"/< The data cleaning flags");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR),G__defined_typename("UncalPMTs"),-1,2,"uncalPMTs=",0,"/< The uncalibrated PMTs for this event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),G__defined_typename("CalPMTs"),-1,2,"calPMTs=",0,"/< The most recent (best) calibration PMTs for this event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),G__defined_typename("map<UInt_t,CalPMTs>"),-1,2,"partialCalPMTs=",0,"/< Calibrated PMTs by calibration identification");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"fitName=",0,"/< The default fit name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR),G__defined_typename("vector<FitVertex>"),-1,2,"fit=",0,"/< A single user-specified fit vertex for easy access");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),G__defined_typename("map<UInt_t,FitCollection>"),-1,2,"fitResults=",0,"/< FitCollection of FitResults, indexed by pass number");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),G__defined_typename("map<UInt_t,ClassifierCollection>"),-1,2,"classifierResults=",0,"/< ClassifierCollection of ClassifierResults, indexed by pass number");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR),G__defined_typename("vector<Digitiser>"),-1,2,"digitiser=",0,"/< The digitiser information (only one exists)");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"clockCount50=",0,"/< 50 MHz clock in tick counts");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"clockCount10=",0,"/< 10 MHz clock in tick counts");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"pmtCalType=",0,"/< Identifier for the PMT calibration type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"gtid=",0,"/< Event ID (Global Trigger ID, GTID)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nhits=",0,"/< Number of normal/inward looking PMT hits in this event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nhits_cleaned=",0,"/< Number of normal/inward looking PMT hits in this event, crosstalk removed");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"inTimeHits100=",0,"/< Maximum number of in time hits in a ~89 ns time window");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"inTimeHits20=",0,"/< Maximum number of in time hits in a ~46 ns time window");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"totalCharge=",0,"/< Integrated uncalibrated charge for this event");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"eSumPeak=",0,"/< Digitized ESUM peak.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"eSumDerivative=",0,"/< Digitized ESUM derivative.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"eSumIntegral=",0,"/< Digitized ESUM integral.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"dataSet=",0,"/< Data Splitter Word");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"trigError=",0,"/< Trigger error bits");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"trigType=",0,"/< Trigger word");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"tubiiTrig=",0,"/< TUBii Trigger word (defaults to 0xC000000 if TUBii data is not present)");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"clockStat10=",0,"/< 10 MHz clock status");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"iscal=",0,"/< True if event tagged by calibration souce");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"ispolling=",0,"/< True if event was during polling");
   }
   G__tag_memvar_reset();
}


   /* map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > */
static void G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   { map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > *p; p=(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > */
static void G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
   { pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > *p; p=(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),104,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > */
static void G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   { map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > *p; p=(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > */
static void G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
   { pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > *p; p=(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),104,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > */
static void G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   { map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > *p; p=(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > */
static void G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
   { pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > *p; p=(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),104,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::TrigHeader */
static void G__setup_memvarRATcLcLDScLcLTrigHeader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader));
   { RAT::DS::TrigHeader *p; p=(RAT::DS::TrigHeader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR),G__defined_typename("map<UShort_t,UShort_t>"),-1,2,"thresholds=",0,"/< MTC/A+ thresholds in DAC counts, keyed on trigger bit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR),G__defined_typename("map<UShort_t,UShort_t>"),-1,2,"offsets=",0,"/< MTC/A+ zero-threshold offsets in DAC counts, keyed on trigger bit");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"trigMask=",0,"/< Mask of enabled triggers");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"pulserRate=",0,"/< Rate of MTC/D pulser");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"MTC_CSR=",0,"/< MTC/D Control/Status register");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"lockoutWidth=",0,"/< Width of the lockout window");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"prescaleFrequency=",0,"/< Frequency of the prescale trigger");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::HeaderInfo */
static void G__setup_memvarRATcLcLDScLcLHeaderInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo));
   { RAT::DS::HeaderInfo *p; p=(RAT::DS::HeaderInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR),G__defined_typename("vector<ECAHeader>"),-1,2,"ecaHeader=",0,"/< The ECA header, should only be 1");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR),G__defined_typename("vector<TrigHeader>"),-1,2,"trigHeader=",0,"/< The trigger header, should only be 1");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > */
static void G__setup_memvarvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   { vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > *p; p=(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > */
static void G__setup_memvarvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   { vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > *p; p=(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MetaDB */
static void G__setup_memvarRATcLcLDScLcLMetaDB(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB));
   { RAT::DS::MetaDB *p; p=(RAT::DS::MetaDB*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),G__defined_typename("vector<std::pair<std::string,std::string> >"),-1,2,"overrides=",0,"/< Vector of override commands pair of table + field descriptor and value");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"files=",0,"/< Vector of files stored as string");
   }
   G__tag_memvar_reset();
}


   /* pair<string,string> */
static void G__setup_memvarpairlEstringcOstringgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR));
   { pair<string,string> *p; p=(pair<string,string>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::Run */
static void G__setup_memvarRATcLcLDScLcLRun(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun));
   { RAT::DS::Run *p; p=(RAT::DS::Run*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR),G__defined_typename("map<std::string,SOC>"),-1,4,"socs=",0,"! This is NOT SAVED to disk, Summary Optical Calibration data indexed by calibration source");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"digitiserTrigSums=",0,"/< The digitiser trigger sums");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,4,"builderVersion=",0,"/< The builder version");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),G__defined_typename("map<UInt_t,BitMask>"),-1,4,"chanSWStatus=",0,"/< The channel software status bits indexed by LCN");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags),-1,-1,4,"dataQualityFlags=",0,"/< The data quality flags");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"runID=",0,"/< The run ID");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"subRunID=",0,"/< The sub run ID");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"date=",0,"/< The run start date, parsed in BeginOfRun in ReconstructClocks proc");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"startTime=",0,"/< The run start time, parsed in BeginOfRun in ReconstructClocks proc");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"runType=",0,"/< The run type word");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"firstGTID=",0,"/< Event ID (Global Trigger ID, GTID) of first event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"validGTID=",0,"/< Event ID (Global Trigger ID, GTID) of first valid event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"nMCEvents=",0,"/< Total number of simulated MC events");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"mcFlag=",0,"/< false: data; true:MC");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"runLength=",0,"! This is NOT SAVED to disk, transient run length for transferring between processors");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::Meta */
static void G__setup_memvarRATcLcLDScLcLMeta(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta));
   { RAT::DS::Meta *p; p=(RAT::DS::Meta*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR),-1,-1,2,"metaDBs=",0,"/< The database information indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"hostNames=",0,"/< The name of the host computer indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"hostSystems=",0,"/< The system type of the host computer indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"ratVersions=",0,"/< The rat base version indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"ratRevisions=",0,"/< The rat revision indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"geant4Versions=",0,"/< The geant4 versions indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"rootVersions=",0,"/< The root versions indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"containsMCFlags=",0,"/< the file contains MC, indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"containsDataFlags=",0,"/< file contains Data, indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"eventsGeneratedCounts=",0,"/< number of mc events generated, indexed by pass");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"eventsStoredCounts=",0,"/< number of events stored, indexed by pass");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   { vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > *p; p=(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCParticle */
static void G__setup_memvarRATcLcLDScLcLMCParticle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle));
   { RAT::DS::MCParticle *p; p=(RAT::DS::MCParticle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"position=",0,"/< Initial position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"polarisation=",0,"/< Initial polarisation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"momentum=",0,"/< Initial momentum");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"pdgCode=",0,"/< Particle Data Group code");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"mcTime=",0,"/< Initial time in the event mc system");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"kineticEnergy=",0,"/< Initial Kinetic energy");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"vertexID=",0,"/< Vertex to which this particle belongs");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"metaInfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCTrackStep */
static void G__setup_memvarRATcLcLDScLcLMCTrackStep(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep));
   { RAT::DS::MCTrackStep *p; p=(RAT::DS::MCTrackStep*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("WorldBoundary=%lldLL",(long long)RAT::DS::MCTrackStep::WorldBoundary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("GeomBoundary=%lldLL",(long long)RAT::DS::MCTrackStep::GeomBoundary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("AtRestDoItProc=%lldLL",(long long)RAT::DS::MCTrackStep::AtRestDoItProc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("AlongStepDoItProc=%lldLL",(long long)RAT::DS::MCTrackStep::AlongStepDoItProc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("PostStepDoItProc=%lldLL",(long long)RAT::DS::MCTrackStep::PostStepDoItProc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("UserDefinedLimit=%lldLL",(long long)RAT::DS::MCTrackStep::UserDefinedLimit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("ExclusivelyForcedProc=%lldLL",(long long)RAT::DS::MCTrackStep::ExclusivelyForcedProc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("Unknown=%lldLL",(long long)RAT::DS::MCTrackStep::Unknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Transportation=%lldLL",(long long)RAT::DS::MCTrackStep::Transportation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("G4FastSimulationManagerProcess=%lldLL",(long long)RAT::DS::MCTrackStep::G4FastSimulationManagerProcess).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("msc=%lldLL",(long long)RAT::DS::MCTrackStep::msc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("ionIoni=%lldLL",(long long)RAT::DS::MCTrackStep::ionIoni).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("nuclearStopping=%lldLL",(long long)RAT::DS::MCTrackStep::nuclearStopping).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("eIoni=%lldLL",(long long)RAT::DS::MCTrackStep::eIoni).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("eBrem=%lldLL",(long long)RAT::DS::MCTrackStep::eBrem).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("annihil=%lldLL",(long long)RAT::DS::MCTrackStep::annihil).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("phot=%lldLL",(long long)RAT::DS::MCTrackStep::phot).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("compt=%lldLL",(long long)RAT::DS::MCTrackStep::compt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("conv=%lldLL",(long long)RAT::DS::MCTrackStep::conv).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Rayl=%lldLL",(long long)RAT::DS::MCTrackStep::Rayl).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("muMsc=%lldLL",(long long)RAT::DS::MCTrackStep::muMsc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("muIoni=%lldLL",(long long)RAT::DS::MCTrackStep::muIoni).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("muBrems=%lldLL",(long long)RAT::DS::MCTrackStep::muBrems).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("muPairProd=%lldLL",(long long)RAT::DS::MCTrackStep::muPairProd).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("CoulombScat=%lldLL",(long long)RAT::DS::MCTrackStep::CoulombScat).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("hIoni=%lldLL",(long long)RAT::DS::MCTrackStep::hIoni).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("hBrems=%lldLL",(long long)RAT::DS::MCTrackStep::hBrems).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("hPairProd=%lldLL",(long long)RAT::DS::MCTrackStep::hPairProd).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("HadronElastic=%lldLL",(long long)RAT::DS::MCTrackStep::HadronElastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("ProtonInelastic=%lldLL",(long long)RAT::DS::MCTrackStep::ProtonInelastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("NeutronInelastic=%lldLL",(long long)RAT::DS::MCTrackStep::NeutronInelastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("nCapture=%lldLL",(long long)RAT::DS::MCTrackStep::nCapture).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("nFission=%lldLL",(long long)RAT::DS::MCTrackStep::nFission).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("NeutronCaptureAtRest=%lldLL",(long long)RAT::DS::MCTrackStep::NeutronCaptureAtRest).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("DeuteronInelastic=%lldLL",(long long)RAT::DS::MCTrackStep::DeuteronInelastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("TritonInelastic=%lldLL",(long long)RAT::DS::MCTrackStep::TritonInelastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("PositronNuclear=%lldLL",(long long)RAT::DS::MCTrackStep::PositronNuclear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("ElectroNuclear=%lldLL",(long long)RAT::DS::MCTrackStep::ElectroNuclear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("PhotonInelastic=%lldLL",(long long)RAT::DS::MCTrackStep::PhotonInelastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("muNuclear=%lldLL",(long long)RAT::DS::MCTrackStep::muNuclear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Decay=%lldLL",(long long)RAT::DS::MCTrackStep::Decay).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("RadioactiveDecay=%lldLL",(long long)RAT::DS::MCTrackStep::RadioactiveDecay).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Absorption=%lldLL",(long long)RAT::DS::MCTrackStep::Absorption).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("OpBoundary=%lldLL",(long long)RAT::DS::MCTrackStep::OpBoundary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Cerenkov=%lldLL",(long long)RAT::DS::MCTrackStep::Cerenkov).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Undefined=%lldLL",(long long)RAT::DS::MCTrackStep::Undefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("start=%lldLL",(long long)RAT::DS::MCTrackStep::start).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("PMTOptMod=%lldLL",(long long)RAT::DS::MCTrackStep::PMTOptMod).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("ConcOptMod=%lldLL",(long long)RAT::DS::MCTrackStep::ConcOptMod).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Reem_compt0=%lldLL",(long long)RAT::DS::MCTrackStep::Reem_compt0).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Reem_compt1=%lldLL",(long long)RAT::DS::MCTrackStep::Reem_compt1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Mie=%lldLL",(long long)RAT::DS::MCTrackStep::Mie).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Scint=%lldLL",(long long)RAT::DS::MCTrackStep::Scint).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Reem_compt2=%lldLL",(long long)RAT::DS::MCTrackStep::Reem_compt2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("Reem_compt3=%lldLL",(long long)RAT::DS::MCTrackStep::Reem_compt3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-2,1,G__FastAllocString(2048).Format("DiscOptMod=%lldLL",(long long)RAT::DS::MCTrackStep::DiscOptMod).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"position=",0,"/< Position at the end of the step");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"polarisation=",0,"/< Polarisation at the end of the step");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"momentum=",0,"/< Momentum at the end of the step");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"startVolume=",0,"/< Name of the volume at the start of this step");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"endVolume=",0,"/< Name of the volume at the end of this step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"length=",0,"/< Length of this step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"globalTime=",0,"/< Global time, since start of event, at the end of the step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"localTime=",0,"/< Local time, since start of track, at the end of the step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"properTime=",0,"/< Proper time at the end of the step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"kineticEnergy=",0,"/< Kinetic energy at the end of the step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"depositedEnergy=",0,"/< Energy deposited over the step");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus),-1,-1,2,"status=",0,"/< The step status");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess),-1,-1,2,"process=",0,"/< The process that has caused the step");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCTrack */
static void G__setup_memvarRATcLcLDScLcLMCTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack));
   { RAT::DS::MCTrack *p; p=(RAT::DS::MCTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpScintillation=%lldLL",(long long)RAT::DS::MCTrack::OpScintillation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpReemission=%lldLL",(long long)RAT::DS::MCTrack::OpReemission).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpCerenkov=%lldLL",(long long)RAT::DS::MCTrack::OpCerenkov).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpAbsorption=%lldLL",(long long)RAT::DS::MCTrack::OpAbsorption).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpRayleigh=%lldLL",(long long)RAT::DS::MCTrack::OpRayleigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpMie=%lldLL",(long long)RAT::DS::MCTrack::OpMie).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("HitConc=%lldLL",(long long)RAT::DS::MCTrack::HitConc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("HitPMT=%lldLL",(long long)RAT::DS::MCTrack::HitPMT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("Compton=%lldLL",(long long)RAT::DS::MCTrack::Compton).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpRayleighH2O=%lldLL",(long long)RAT::DS::MCTrack::OpRayleighH2O).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpRayleighAV=%lldLL",(long long)RAT::DS::MCTrack::OpRayleighAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpRayleighInnerAV=%lldLL",(long long)RAT::DS::MCTrack::OpRayleighInnerAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpMieH2O=%lldLL",(long long)RAT::DS::MCTrack::OpMieH2O).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpMieAV=%lldLL",(long long)RAT::DS::MCTrack::OpMieAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("OpMieInnerAV=%lldLL",(long long)RAT::DS::MCTrack::OpMieInnerAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag),-1,-2,1,G__FastAllocString(2048).Format("CoulombScatter=%lldLL",(long long)RAT::DS::MCTrack::CoulombScatter).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR),G__defined_typename("vector<MCTrackStep>"),-1,2,"steps=",0,"/< The track steps for this track");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"particleName=",0,"/< Particle name, often needed alongside the PDG Code");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),-1,-1,2,"summaryFlag=",0,"/< A bitmask summarising what this track has done during the event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"trackID=",0,"/< The unique ID for the track");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"parentID=",0,"/< The ID of the parent track");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"pdgCode=",0,"/< The PDG code for the particle type this track represents");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"length=",0,"/< The total length of the track");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"depositedEnergy=",0,"/< The total deposited energy of the track");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"weight=",0,"/< The weight of the track");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   { vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > *p; p=(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCPhoton */
static void G__setup_memvarRATcLcLDScLcLMCPhoton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton));
   { RAT::DS::MCPhoton *p; p=(RAT::DS::MCPhoton*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate),-1,-2,1,G__FastAllocString(2048).Format("eAbsorbed=%lldLL",(long long)RAT::DS::MCPhoton::eAbsorbed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate),-1,-2,1,G__FastAllocString(2048).Format("eReflected=%lldLL",(long long)RAT::DS::MCPhoton::eReflected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate),-1,-2,1,G__FastAllocString(2048).Format("ePhotoelectron=%lldLL",(long long)RAT::DS::MCPhoton::ePhotoelectron).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate),-1,-2,1,G__FastAllocString(2048).Format("eUnknown=%lldLL",(long long)RAT::DS::MCPhoton::eUnknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"inPosition=",0,"/< Local coordinate position of the photon on entry to the bucket/pmt");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"inDirection=",0,"/< Local coordinate direction of the photon on entry");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"inPolarisation=",0,"/< Local coordinate polarisation of the photon on entry");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"outPosition=",0,"/< Local coordinate position of the photon on exit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"outDirection=",0,"/< Local coordinate direction of the photon on exit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"outPolarisation=",0,"/< Local coordinate polarisation of the photon on exit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"inTime=",0,"/< Global mc time on entry");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"outTime=",0,"/< Global mc time on exit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"energy=",0,"/< Energy of the photon in MeV");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"weight=",0,"/< Relative weight assigned to this photon");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"photonTrackID=",0,"/< The photon track ID for this photon");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate),-1,-1,2,"fate=",0,"/< The fate of the photon");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"pmtID=",0,"/< The ID of the PMT this photon entered");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCPE */
static void G__setup_memvarRATcLcLDScLcLMCPE(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE));
   { RAT::DS::MCPE *p; p=(RAT::DS::MCPE*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hUnknown=%lldLL",(long long)RAT::DS::MCPE::hUnknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hCherenkov=%lldLL",(long long)RAT::DS::MCPE::hCherenkov).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hScintillation=%lldLL",(long long)RAT::DS::MCPE::hScintillation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hRayleighScatt=%lldLL",(long long)RAT::DS::MCPE::hRayleighScatt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hMieScatt=%lldLL",(long long)RAT::DS::MCPE::hMieScatt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLS=%lldLL",(long long)RAT::DS::MCPE::hWLS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP0=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP0).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP1=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP2=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP3=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP4=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP4).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory),-1,-2,1,G__FastAllocString(2048).Format("hWLSCOMP5=%lldLL",(long long)RAT::DS::MCPE::hWLSCOMP5).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhHistoryStatus),-1,-2,1,G__FastAllocString(2048).Format("hUnset=%lldLL",(long long)RAT::DS::MCPE::hUnset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhHistoryStatus),-1,-2,1,G__FastAllocString(2048).Format("hSet=%lldLL",(long long)RAT::DS::MCPE::hSet).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),G__defined_typename("XYZVectorF"),-1,2,"position=",0,"/< Local co-ordinate position of the photoelectron at creation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"creationTime=",0,"/< Global MC time for the creation of the photoelectron");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"frontEndTime=",0,"/< Front end detection time in Global MC coordinates.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"charge=",0,"/< Charge of the photoelectron (always 1? -PGJ)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"photonTrackID=",0,"/< The track ID of the photon that caused the photoelectron creation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"noise=",0,"/< Flag if this photoelectron is noise rather than from photon origin");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"afterpulse=",0,"/< Flag if this photoelectron is an afterpulse rather than from photon origin");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"photonHistory=",0,"/< Word of the processes this photon was subject to");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCPMT */
static void G__setup_memvarRATcLcLDScLcLMCPMT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT));
   { RAT::DS::MCPMT *p; p=(RAT::DS::MCPMT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR),G__defined_typename("vector<MCPhoton>"),-1,2,"mcPhotons=",0,"/< The photon information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR),G__defined_typename("vector<MCPE>"),-1,2,"mcPEs=",0,"/< The photoelectron information");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"id=",0,"/< Logical Channel Number of the PMT");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   { vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > *p; p=(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   { vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > *p; p=(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MC */
static void G__setup_memvarRATcLcLDScLcLMC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC));
   { RAT::DS::MC *p; p=(RAT::DS::MC*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR),G__defined_typename("vector<MCParticle>"),-1,2,"particles=",0,"/< The primary particles for this event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR),G__defined_typename("vector<MCParticle>"),-1,2,"parents=",0,"/< Primary particle parent particles e.g. neutrino or decay parent");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR),G__defined_typename("vector<MCTrack>"),-1,2,"tracks=",0,"/< Particle tracks as simulated (empty by default)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,2,"trackIDs=",0,"/< Vector of Track IDs(empty by default)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR),G__defined_typename("vector<MCPMT>"),-1,2,"pmts=",0,"/< PMTs that record at least one photoelectron in the simulation before the daq, or a photon in the concentrator bucket");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),G__defined_typename("MCHits"),-1,2,"unbuiltHits=",0,"/< Unbuilt MCHits, hits not associated with a detector event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime),-1,-1,2,"universalTime=",0,"/< Universal time of the event");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"mcTime=",0,"/< MC time i.e. relative to beginning of run in ns");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"mcid=",0,"/< The ID of this event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"mcPECount=",0,"/< Total number of photoelectrons (before the daq)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nCherPhotons=",0,"/< Number of cerenkov photons created in the event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nScintPhotons=",0,"/< Number of scintillation photons created in the event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nReemittedPhotons=",0,"/< Number of reemitted photons in the event");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"numDirPE=",0,"/< Used with GenPMTEff event generator");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"intialScintTime=",0,"/< Initial time of scintillation (t_zero)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"scintEnergyDeposit=",0,"/< Total energy deposited in the scintillator");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"scintQuenchedEnergyDeposit=",0,"/< Total visible/quenched energy deposited in the scintillator");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   { vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > *p; p=(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   { vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > *p; p=(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   { vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > *p; p=(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::MCEV */
static void G__setup_memvarRATcLcLDScLcLMCEV(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV));
   { RAT::DS::MCEV *p; p=(RAT::DS::MCEV*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),G__defined_typename("MCHits"),-1,2,"hits=",0,"/< The collection of MCHits for this event");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"gtid=",0,"/< Event Global Trigger ID, GTID");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"gtTime=",0,"/< Trigger time of the event in the MC system");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fullTrigType=",0,"/< Trigger word, including triggers that weren't latched");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::Entry */
static void G__setup_memvarRATcLcLDScLcLEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry));
   { RAT::DS::Entry *p; p=(RAT::DS::Entry*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR),G__defined_typename("vector<MC>"),-1,4,"mc=",0,"/< The Monte Carlo data branch");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR),G__defined_typename("vector<MCEV>"),-1,4,"mcevs=",0,"/< The mc-data triggered events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR),G__defined_typename("vector<EV>"),-1,4,"evs=",0,"/< The data triggered events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR),G__defined_typename("vector<HeaderInfo>"),-1,4,"headerInfo=",0,"/< The header info branche for this event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib),-1,-1,4,"calib=",0,"/< MUST Delete when the DB works properly");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"runID=",0,"/< The run ID");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"subRunID=",0,"/< The sub run ID");
   G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"seed=",0,"/< The seed at the start of this event");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MC,allocator<RAT::DS::MC> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   { vector<RAT::DS::MC,allocator<RAT::DS::MC> > *p; p=(vector<RAT::DS::MC,allocator<RAT::DS::MC> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > */
static void G__setup_memvarvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   { vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > *p; p=(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::EV,allocator<RAT::DS::EV> > */
static void G__setup_memvarvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   { vector<RAT::DS::EV,allocator<RAT::DS::EV> > *p; p=(vector<RAT::DS::EV,allocator<RAT::DS::EV> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > */
static void G__setup_memvarvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   { vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > *p; p=(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::SOCPMT */
static void G__setup_memvarRATcLcLDScLcLSOCPMT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT));
   { RAT::DS::SOCPMT *p; p=(RAT::DS::SOCPMT*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eSuccess=%lldLL",(long long)RAT::DS::SOCPMT::eSuccess).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eTooFewEntries=%lldLL",(long long)RAT::DS::SOCPMT::eTooFewEntries).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eNoData=%lldLL",(long long)RAT::DS::SOCPMT::eNoData).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eBoundaryError=%lldLL",(long long)RAT::DS::SOCPMT::eBoundaryError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eNoConvergence=%lldLL",(long long)RAT::DS::SOCPMT::eNoConvergence).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("ePeakOutsideOfWindow=%lldLL",(long long)RAT::DS::SOCPMT::ePeakOutsideOfWindow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-2,1,G__FastAllocString(2048).Format("eUnknown=%lldLL",(long long)RAT::DS::SOCPMT::eUnknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"TACs=",0,"/< All hit TAC values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"QHLs=",0,"/< All hit QHL values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"QHSs=",0,"/< All hit QHS values");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"lcn=",0,"/< LCN value for this channel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"manipTimeOfFlight=",0,"/< Time of flight to this channel calculated from manip position and light path, using wavelength");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"promptOccupancy=",0,"/< Count of hits in +-4ns peak");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"tacCentroid=",0,"/< Average time of prompt peak");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"tacError=",0,"/< Width of prompt peak");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus),-1,-1,2,"peakFindOk=",0,"/< PeakFinder successful");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"shadowRelativeOccupancy=",0,"/< Relative occupancy of this channel [0,1], 0 fully obscured");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"ropeShadowRelativeOccupancy=",0,"/< Relative occupancy of this channel w/wo HD ropes [0,1], 0 fully obscured");
   }
   G__tag_memvar_reset();
}


   /* RAT::DS::SOC */
static void G__setup_memvarRATcLcLDScLcLSOC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   { RAT::DS::SOC *p; p=(RAT::DS::SOC*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),G__defined_typename("map<UInt_t,SOCPMT>"),-1,2,"pmts=",0,"/< The SOCPMT information indexed by lcn");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR),-1,-1,2,"fitResults=",0,"/< The reconstructed source information, indexed by fit name");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"globalTimeOffset=",0,"/< Time offset for this run common to all channels");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"nPulsesTriggered=",0,"Number of pulses generated or acquired, passing trigger selection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib),-1,-1,2,"calib=",0,"/< MUST Delete when the DB works properly");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"sourceID=",0,"/< The source ID for simple reference.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"runID=",0,"/< The run ID");
   }
   G__tag_memvar_reset();
}


   /* map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > */
static void G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   { map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > *p; p=(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* pair<unsigned int,RAT::DS::SOCPMT> */
static void G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
   { pair<unsigned int,RAT::DS::SOCPMT> *p; p=(pair<unsigned int,RAT::DS::SOCPMT>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->first)-(long)(p)),104,0,0,-1,-1,-1,1,"first=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT),-1,-1,1,"second=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::DataCleaningBits */
static void G__setup_memvarRATcLcLDUcLcLDataCleaningBits(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits));
   { RAT::DU::DataCleaningBits *p; p=(RAT::DU::DataCleaningBits*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PrescaleCut=%lldLL",(long long)RAT::DU::DataCleaningBits::PrescaleCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ZeroZeroCut=%lldLL",(long long)RAT::DU::DataCleaningBits::ZeroZeroCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("CrateIsotropy=%lldLL",(long long)RAT::DU::DataCleaningBits::CrateIsotropy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("FTSCut=%lldLL",(long long)RAT::DU::DataCleaningBits::FTSCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("FlasherGeoCut=%lldLL",(long long)RAT::DU::DataCleaningBits::FlasherGeoCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ITCTimeSpreadCut=%lldLL",(long long)RAT::DU::DataCleaningBits::ITCTimeSpreadCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("JunkCut=%lldLL",(long long)RAT::DU::DataCleaningBits::JunkCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MuonTag=%lldLL",(long long)RAT::DU::DataCleaningBits::MuonTag).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("NeckCut=%lldLL",(long long)RAT::DU::DataCleaningBits::NeckCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("OwlCut=%lldLL",(long long)RAT::DU::DataCleaningBits::OwlCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QClusterCut=%lldLL",(long long)RAT::DU::DataCleaningBits::QClusterCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QvNhit=%lldLL",(long long)RAT::DU::DataCleaningBits::QvNhit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QvTCut=%lldLL",(long long)RAT::DU::DataCleaningBits::QvTCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RingOfFire=%lldLL",(long long)RAT::DU::DataCleaningBits::RingOfFire).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("TwoPassMuonFollowerCutShort=%lldLL",(long long)RAT::DU::DataCleaningBits::TwoPassMuonFollowerCutShort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("TwoPassMuonFollowerCutLong=%lldLL",(long long)RAT::DU::DataCleaningBits::TwoPassMuonFollowerCutLong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("CAENCut=%lldLL",(long long)RAT::DU::DataCleaningBits::CAENCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("NothingCut=%lldLL",(long long)RAT::DU::DataCleaningBits::NothingCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("NhitCut=%lldLL",(long long)RAT::DU::DataCleaningBits::NhitCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ThresholdFlasherCut=%lldLL",(long long)RAT::DU::DataCleaningBits::ThresholdFlasherCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PollingCut=%lldLL",(long long)RAT::DU::DataCleaningBits::PollingCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RetriggerCut=%lldLL",(long long)RAT::DU::DataCleaningBits::RetriggerCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("FirstEventFlag=%lldLL",(long long)RAT::DU::DataCleaningBits::FirstEventFlag).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("TPBurstCut=%lldLL",(long long)RAT::DU::DataCleaningBits::TPBurstCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MissedMuonFollowerCut=%lldLL",(long long)RAT::DU::DataCleaningBits::MissedMuonFollowerCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MissingCaenData=%lldLL",(long long)RAT::DU::DataCleaningBits::MissingCaenData).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PedCut=%lldLL",(long long)RAT::DU::DataCleaningBits::PedCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("AtmosphericCut=%lldLL",(long long)RAT::DU::DataCleaningBits::AtmosphericCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("EmptyCrate=%lldLL",(long long)RAT::DU::DataCleaningBits::EmptyCrate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MissedCountBurstCut=%lldLL",(long long)RAT::DU::DataCleaningBits::MissedCountBurstCut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow0=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow0).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow1=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow2=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow3=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow4=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow4).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow5=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow5).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow6=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow6).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow7=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow7).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow8=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow8).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindLow9=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindLow9).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh0=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh0).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh1=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh2=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh3=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh4=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh4).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh5=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh5).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh6=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh6).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh7=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh7).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh8=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh8).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("WaterBlindHigh9=%lldLL",(long long)RAT::DU::DataCleaningBits::WaterBlindHigh9).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),G__defined_typename("map<std::string,size_t>"),-1,4,"fBitMap=",0,"/< Mapping between bit name and bit position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),G__defined_typename("map<size_t,std::string>"),-1,4,"fInverseBitMap=",0,"/< Opposite mapping, bit position to bit name");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::DataQualityBits */
static void G__setup_memvarRATcLcLDUcLcLDataQualityBits(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits));
   { RAT::DU::DataQualityBits *p; p=(RAT::DU::DataQualityBits*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RunType=%lldLL",(long long)RAT::DU::DataQualityBits::RunType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MCFlag=%lldLL",(long long)RAT::DU::DataQualityBits::MCFlag).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("Trigger=%lldLL",(long long)RAT::DU::DataQualityBits::Trigger).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RunLength=%lldLL",(long long)RAT::DU::DataQualityBits::RunLength).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("GeneralCoverage=%lldLL",(long long)RAT::DU::DataQualityBits::GeneralCoverage).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("CrateCoverage=%lldLL",(long long)RAT::DU::DataQualityBits::CrateCoverage).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PanelCoverage=%lldLL",(long long)RAT::DU::DataQualityBits::PanelCoverage).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RunHeader=%lldLL",(long long)RAT::DU::DataQualityBits::RunHeader).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("DeltaTComparison=%lldLL",(long long)RAT::DU::DataQualityBits::DeltaTComparison).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ClockForward=%lldLL",(long long)RAT::DU::DataQualityBits::ClockForward).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("EventSeparation=%lldLL",(long long)RAT::DU::DataQualityBits::EventSeparation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("Retriggers=%lldLL",(long long)RAT::DU::DataQualityBits::Retriggers).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("EventRate=%lldLL",(long long)RAT::DU::DataQualityBits::EventRate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PulseSeparation=%lldLL",(long long)RAT::DU::DataQualityBits::PulseSeparation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("MaxNhit=%lldLL",(long long)RAT::DU::DataQualityBits::MaxNhit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("AvgNhit=%lldLL",(long long)RAT::DU::DataQualityBits::AvgNhit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("Fibre=%lldLL",(long long)RAT::DU::DataQualityBits::Fibre).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PeakNumber=%lldLL",(long long)RAT::DU::DataQualityBits::PeakNumber).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PeakAmplitude=%lldLL",(long long)RAT::DU::DataQualityBits::PeakAmplitude).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PromptTime=%lldLL",(long long)RAT::DU::DataQualityBits::PromptTime).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PeakTime=%lldLL",(long long)RAT::DU::DataQualityBits::PeakTime).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("N100LTriggerRate=%lldLL",(long long)RAT::DU::DataQualityBits::N100LTriggerRate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ESumHTriggerRate=%lldLL",(long long)RAT::DU::DataQualityBits::ESumHTriggerRate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbTimeCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbTimeCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbPosCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbPosCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbqhsLowCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbqhsLowCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbqhsPeakCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbqhsPeakCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbqhsHighCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbqhsHighCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbNHitCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbNHitCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbNZeroCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbNZeroCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbFullOccupancyMeanCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbFullOccupancyMeanCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbFullOccupancySpreadCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbFullOccupancySpreadCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbOccupancyRatioMeanCheckCentralRun=%lldLL",(long long)RAT::DU::DataQualityBits::lbOccupancyRatioMeanCheckCentralRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbOccupancyRatioSpreadCheckCentralRun=%lldLL",(long long)RAT::DU::DataQualityBits::lbOccupancyRatioSpreadCheckCentralRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbOccupancyRatioMeanCheckPreviousRun=%lldLL",(long long)RAT::DU::DataQualityBits::lbOccupancyRatioMeanCheckPreviousRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbOccupancyRatioSpreadCheckPreviousRun=%lldLL",(long long)RAT::DU::DataQualityBits::lbOccupancyRatioSpreadCheckPreviousRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbPromptOccupancyMeanCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbPromptOccupancyMeanCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbPromptOccupancySpreadCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbPromptOccupancySpreadCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbPMTMeanTimeCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbPMTMeanTimeCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("lbPMTTimeErrorCheck=%lldLL",(long long)RAT::DU::DataQualityBits::lbPMTTimeErrorCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("UT10MhzClockCheck=%lldLL",(long long)RAT::DU::DataQualityBits::UT10MhzClockCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("smellieCorrectFibre=%lldLL",(long long)RAT::DU::DataQualityBits::smellieCorrectFibre).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("smellieIntensityCheck=%lldLL",(long long)RAT::DU::DataQualityBits::smellieIntensityCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("smellieFrequencyCheck=%lldLL",(long long)RAT::DU::DataQualityBits::smellieFrequencyCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("smellieNumberOfEventsCheck=%lldLL",(long long)RAT::DU::DataQualityBits::smellieNumberOfEventsCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("n16NumberOfEventsCheck=%lldLL",(long long)RAT::DU::DataQualityBits::n16NumberOfEventsCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("n16MeanNHitCheck=%lldLL",(long long)RAT::DU::DataQualityBits::n16MeanNHitCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("n16NHitSpreadCheck=%lldLL",(long long)RAT::DU::DataQualityBits::n16NHitSpreadCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("n16FitPositionCheck=%lldLL",(long long)RAT::DU::DataQualityBits::n16FitPositionCheck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("triggerProcBitFlipGTID=%lldLL",(long long)RAT::DU::DataQualityBits::triggerProcBitFlipGTID).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("triggerProcMissingGTID=%lldLL",(long long)RAT::DU::DataQualityBits::triggerProcMissingGTID).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),G__defined_typename("map<std::string,size_t>"),-1,4,"fBitMap=",0,"/< Mapping between bit name and bit position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),G__defined_typename("map<size_t,std::string>"),-1,4,"fInverseBitMap=",0,"/< Opposite mapping, bit position to bit name");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ChanSWStatus */
static void G__setup_memvarRATcLcLDUcLcLChanSWStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus));
   { RAT::DU::ChanSWStatus *p; p=(RAT::DU::ChanSWStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("RunLength=%lldLL",(long long)RAT::DU::ChanSWStatus::RunLength).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("HighOcc=%lldLL",(long long)RAT::DU::ChanSWStatus::HighOcc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("LowOcc=%lldLL",(long long)RAT::DU::ChanSWStatus::LowOcc).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QHS=%lldLL",(long long)RAT::DU::ChanSWStatus::QHS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QHL=%lldLL",(long long)RAT::DU::ChanSWStatus::QHL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("QLX=%lldLL",(long long)RAT::DU::ChanSWStatus::QLX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("TAC=%lldLL",(long long)RAT::DU::ChanSWStatus::TAC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("ECA=%lldLL",(long long)RAT::DU::ChanSWStatus::ECA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("PCA=%lldLL",(long long)RAT::DU::ChanSWStatus::PCA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("CHS=%lldLL",(long long)RAT::DU::ChanSWStatus::CHS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit),-1,-2,1,G__FastAllocString(2048).Format("CHS_STANDARD=%lldLL",(long long)RAT::DU::ChanSWStatus::CHS_STANDARD).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"channelMask=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fdefaultCSS=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fResultExist=",0,"True if the CSS_RESULT table is available.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),G__defined_typename("map<std::string,size_t>"),-1,4,"fBitMap=",0,"/< Mapping between bit name and bit position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),G__defined_typename("map<size_t,std::string>"),-1,4,"fInverseBitMap=",0,"/< Opposite mapping, bit position to bit name");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::TrigBits */
static void G__setup_memvarRATcLcLDUcLcLTrigBits(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits));
   { RAT::DU::TrigBits *p; p=(RAT::DU::TrigBits*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("N100Low=%lldLL",(long long)RAT::DU::TrigBits::N100Low).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("N100Med=%lldLL",(long long)RAT::DU::TrigBits::N100Med).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("N100High=%lldLL",(long long)RAT::DU::TrigBits::N100High).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("N20=%lldLL",(long long)RAT::DU::TrigBits::N20).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("N20LB=%lldLL",(long long)RAT::DU::TrigBits::N20LB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("ESLow=%lldLL",(long long)RAT::DU::TrigBits::ESLow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("ESHigh=%lldLL",(long long)RAT::DU::TrigBits::ESHigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("OWLN=%lldLL",(long long)RAT::DU::TrigBits::OWLN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("OWLESLow=%lldLL",(long long)RAT::DU::TrigBits::OWLESLow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("OWLESHigh=%lldLL",(long long)RAT::DU::TrigBits::OWLESHigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("PulseGT=%lldLL",(long long)RAT::DU::TrigBits::PulseGT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("Prescale=%lldLL",(long long)RAT::DU::TrigBits::Prescale).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("Pedestal=%lldLL",(long long)RAT::DU::TrigBits::Pedestal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("Pong=%lldLL",(long long)RAT::DU::TrigBits::Pong).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("Sync=%lldLL",(long long)RAT::DU::TrigBits::Sync).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXTASY=%lldLL",(long long)RAT::DU::TrigBits::EXTASY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT2=%lldLL",(long long)RAT::DU::TrigBits::EXT2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT3=%lldLL",(long long)RAT::DU::TrigBits::EXT3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT4=%lldLL",(long long)RAT::DU::TrigBits::EXT4).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT5=%lldLL",(long long)RAT::DU::TrigBits::EXT5).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT6=%lldLL",(long long)RAT::DU::TrigBits::EXT6).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT7=%lldLL",(long long)RAT::DU::TrigBits::EXT7).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("EXT8PulseAsy=%lldLL",(long long)RAT::DU::TrigBits::EXT8PulseAsy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("SPRaw=%lldLL",(long long)RAT::DU::TrigBits::SPRaw).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("NCD=%lldLL",(long long)RAT::DU::TrigBits::NCD).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("SoftGT=%lldLL",(long long)RAT::DU::TrigBits::SoftGT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("MissTrig=%lldLL",(long long)RAT::DU::TrigBits::MissTrig).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR),G__defined_typename("map<std::string,size_t>"),-2,4,"fsBitMap=",0,"/< Mapping between bit name and bit position");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR),G__defined_typename("map<size_t,std::string>"),-2,4,"fsInverseBitMap=",0,"/< Opposite mapping, bit position to bit name");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::DSReader */
static void G__setup_memvarRATcLcLDUcLcLDSReader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader));
   { RAT::DU::DSReader *p; p=(RAT::DU::DSReader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TChain),-1,-1,2,"fT=",0,"/< The DS T Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TChain),-1,-1,2,"fRunT=",0,"/< The DS runT Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry),-1,-1,2,"fDS=",0,"/< The current entry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun),-1,-1,2,"fRun=",0,"/< The current run");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta),-1,-1,2,"fMeta=",0,"/< The current Meta information");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fCurrentEntry=",0,"/< The current entry index");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fTotalEntries=",0,"/< The total number of entries");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fCurrentRun=",0,"/< The current run index");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fTotalRuns=",0,"/< The total number of runs");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fUseMeta=",0,"/< Flag to use or ignore Meta information in file. Default true.");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::EffectiveVelocity */
static void G__setup_memvarRATcLcLDUcLcLEffectiveVelocity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity));
   { RAT::DU::EffectiveVelocity *p; p=(RAT::DU::EffectiveVelocity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fInnerAVVelocity=",0,"/< Effective target (inner_av) effective velocity");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fAVVelocity=",0,"/< Effective av effective velocity");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fWaterVelocity=",0,"/< Effective water effective velocity");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fOffset=",0,"/< Offset required from fit, time taken on average in PMT.");
   }
   G__tag_memvar_reset();
}


   /* RAT::DBTable */
static void G__setup_memvarRATcLcLDBTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   { RAT::DBTable *p; p=(RAT::DBTable*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("NOTFOUND=%lldLL",(long long)RAT::DBTable::NOTFOUND).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("INTEGER=%lldLL",(long long)RAT::DBTable::INTEGER).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("DOUBLE=%lldLL",(long long)RAT::DBTable::DOUBLE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("STRING=%lldLL",(long long)RAT::DBTable::STRING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("BOOLEAN=%lldLL",(long long)RAT::DBTable::BOOLEAN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("INTEGER_ARRAY=%lldLL",(long long)RAT::DBTable::INTEGER_ARRAY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("DOUBLE_ARRAY=%lldLL",(long long)RAT::DBTable::DOUBLE_ARRAY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("STRING_ARRAY=%lldLL",(long long)RAT::DBTable::STRING_ARRAY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("BOOLEAN_ARRAY=%lldLL",(long long)RAT::DBTable::BOOLEAN_ARRAY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("JSON=%lldLL",(long long)RAT::DBTable::JSON).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType),-1,-2,1,G__FastAllocString(2048).Format("EMPTY_ARRAY=%lldLL",(long long)RAT::DBTable::EMPTY_ARRAY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"tblname=",0,"*< Name of table */");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"index=",0,"*< Index of table */");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"run_begin=",0,"*< First run in which this table is valid */");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"run_end=",0,"*< Last run in which this table is valid */");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"pass_number=",0,"*< Pass number of this table */");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("size_t"),-1,2,"bytes=",0,"*< Number of bytes required by values.  Approximate */");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue),-1,-1,2,"table=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_stlpluscLcLhashlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRsPgR),-1,-1,2,"arrayTypeCache=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DB */
static void G__setup_memvarRATcLcLDB(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB));
   { RAT::DB *p; p=(RAT::DB*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,1,G__FastAllocString(2048).Format("MAXPASS=%lldLL",(long long)RAT::DB::MAXPASS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,1,G__FastAllocString(2048).Format("DBINFINITY=%lldLL",(long long)RAT::DB::DBINFINITY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fAllowDanger=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fAllowDangerWhitelist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-2,2,"fDBSetList=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR),G__defined_typename("map<std::pair<std::string,std::string>,int>"),-1,2,"fPassMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_listlERATcLcLDBLinkmUcOallocatorlERATcLcLDBLinkmUgRsPgR),G__defined_typename("list<RAT::DBLink*>"),-1,2,"links=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"server=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),G__defined_typename("set<std::string>"),-1,2,"tableNamesOnServer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR),G__defined_typename("set<RAT::DBTableKey>"),-1,2,"tablesNotOnServer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend),-1,-1,2,"fDbBackend=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),G__defined_typename("DBTableSet"),-1,2,"tables_default=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),G__defined_typename("DBTableSet"),-1,2,"tables_user=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR),G__defined_typename("DBTableSet"),-1,2,"tables_run=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_dequelERATcLcLDBTableKeycOallocatorlERATcLcLDBTableKeygRsPgR),G__defined_typename("deque<RAT::DBTableKey>"),-1,2,"tablesFromServer=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fRunID=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),G__defined_typename("vector<std::pair<std::string,std::string> >"),-1,2,"fTblNoDefaultPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR),G__defined_typename("vector<std::pair<std::string,std::string> >"),-1,2,"fTblNoDefaultPlaneUser=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fTblNoDefaultPlaneExceptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),G__defined_typename("set<std::string>"),-1,2,"fFileList=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"fDbTag=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-2,2,"default_server=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fAirplaneMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDefaultPlaneLockEnabled=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDefaultsLoaded=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DBLink */
static void G__setup_memvarRATcLcLDBLink(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink));
   { RAT::DBLink *p; p=(RAT::DBLink*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB),-1,-1,2,"db=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"tblname=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"index=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"currentRun=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"loadFromDefaultPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"pass=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"validVersion=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::PgSQLBackend */
static void G__setup_memvarRATcLcLPgSQLBackend(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend));
   { RAT::PgSQLBackend *p; p=(RAT::PgSQLBackend*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_pg_conn),G__defined_typename("PGconn"),-1,2,"pg_conn_=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_pg_result),G__defined_typename("PGresult"),-1,2,"pg_res_=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_pgNotify),G__defined_typename("PGnotify"),-1,2,"pg_notify_=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"server_url_=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"conn_options_=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"num_reconn_=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"num_sec_wait_=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"bor_done_=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"bor_warn_given_=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"ratdb_tag_=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"ratdb_header_tbl_=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-2,2,"ratdb_header_tbl_base_=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* simple_ptr_nocopy<RAT::DBTable> */
static void G__setup_memvarsimple_ptr_nocopylERATcLcLDBTablegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   { simple_ptr_nocopy<RAT::DBTable> *p; p=(simple_ptr_nocopy<RAT::DBTable>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable),-1,-1,2,"m_pointer=",0,(char*)NULL);
   G__memvar_setup((void*)0,72,0,0,-1,-1,-1,2,"m_count=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* simple_ptr_nocopy<RAT::DBLink> */
static void G__setup_memvarsimple_ptr_nocopylERATcLcLDBLinkgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   { simple_ptr_nocopy<RAT::DBLink> *p; p=(simple_ptr_nocopy<RAT::DBLink>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink),-1,-1,2,"m_pointer=",0,(char*)NULL);
   G__memvar_setup((void*)0,72,0,0,-1,-1,-1,2,"m_count=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DBTable*,allocator<RAT::DBTable*> > */
static void G__setup_memvarvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   { vector<RAT::DBTable*,allocator<RAT::DBTable*> > *p; p=(vector<RAT::DBTable*,allocator<RAT::DBTable*> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::GroupVelocity */
static void G__setup_memvarRATcLcLDUcLcLGroupVelocity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity));
   { RAT::DU::GroupVelocity *p; p=(RAT::DU::GroupVelocity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-1,4,"fInnerAVGroupVelocity=",0,"/< Group Velocity as a function of energy in scintillator");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-1,4,"fAVGroupVelocity=",0,"/< Group Velocity as a function of energy in av");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-1,4,"fWaterGroupVelocity=",0,"/< Group Velocity as a function of energy in water");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::LightPathCalculator */
static void G__setup_memvarRATcLcLDUcLcLLightPathCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator));
   { RAT::DU::LightPathCalculator *p; p=(RAT::DU::LightPathCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNeckInnerRadius=",0,"/< Radius of the inner neck region");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNeckOuterRadius=",0,"/< Radius of the outer neck");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVInnerRadius=",0,"/< Radius of the scint region");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVOuterRadius=",0,"/< Radius of the AV region");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPMTRadius=",0,"/< Radius of the PMT bucket");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFillZ=",0,"/< z position of the partial fill");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fInnerAVRI=",0,"/< Scintillator refractive index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fUpperTargetRI=",0,"/< The 'filled' region of the detector refractive index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fLowerTargetRI=",0,"/< The 'un-filled' region of the detector refractive index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fAVRI=",0,"/< AV refractive index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fWaterRI=",0,"/< Water refractive index");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLoopCeiling=",0,"/< Iteration Ceiling for algortithm loop");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFinalLoopSize=",0,"/< Final loop value which meets locality conditions");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPathPrecision=",0,"/< The accepted path proximity/tolerance to the PMT location [mm]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInnerAVRIVal=",0,"/< The value of the scintillator refractive index used for this path");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fUpperTargetRIVal=",0,"/< The value of the upper target volume index used for this path (partial fill)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLowerTargetRIVal=",0,"/< The value of the lower target volume index used for this path (partial fill)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVRIVal=",0,"/< The value of the AV refractive index used for this path");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWaterRIVal=",0,"/< The value of the water refractive index used for this path");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fIncidentVecOnPMT=",0,"/< Final light path direction (unit normalised)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fInitialLightVec=",0,"/< Initial light path direction (unit normalised)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fStartPos=",0,"/< Start position of the light path");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fEndPos=",0,"/< Required end position of the light path");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fLightPathEndPos=",0,"/< Calculated end position of the light path");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPMTTargetTheta=",0,"/< The target PMT theta angle for the light path");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsTIR=",0,"/< TRUE: Total Internal Reflection encountered FALSE: It wasn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fResvHit=",0,"/< TRUE: Difficult path to resolve and calculate FALSE: It wasn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fXAVNeck=",0,"/< TRUE: Path entered neck region FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fELLIEEvent=",0,"/< TRUE: Reflected distances in water off of AV on PMTs near starting position required");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStraightLine=",0,"/< TRUE: Light Path is a straight line approximation FALSE: It isn't");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnAV1st=",0,"/< Point on AV where light path first hits the AV");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnAV2nd=",0,"/< Point on AV where light path hits the AV a second time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnAV3rd=",0,"/< Point on AV where light path hits the AV a third time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnAV4th=",0,"/< Point on AV where light path hits the AV a fourth time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnNeck1st=",0,"/< Point on the Neck where the light path hits a first time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnNeck2nd=",0,"/< Point on the Neck where the light path hits a second time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnNeck3rd=",0,"/< Point on the Neck where the light path hits a third time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPointOnNeck4th=",0,"/< Point on the Neck where the light path hits a fourth time");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLeLightPathType),-1,-1,4,"fLightPathType=",0,"/< Light path type, based on what regions of the detector the path enters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR),G__defined_typename("map<eLightPathType,std::string>"),-1,4,"fLightPathTypeMap=",0,"/< Map containing a descriptor for the light path type");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInInnerAV=",0,"/< Distance in the scintillator region");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInUpperTarget=",0,"/< Distance in the upper target region (partial fill geometry)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInLowerTarget=",0,"/< Distance in the lower target region (partial fill geometry)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInAV=",0,"/< Distance in the acrylic region of the AV");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInWater=",0,"/< Distance in the water region");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInNeckInnerAV=",0,"/< Distance through the scintillator region in the neck (if GetXAVNeck() = TRUE)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInNeckAV=",0,"/< Distance through the acrylic of the AV region in the neck (if GetXAVNeck() = TRUE)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistInNeckWater=",0,"/< Distance through the water region in the neck (if GetXAVNeck() = TRUE)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergy=",0,"/< The value of the wavelength in MeV");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSolidAngle=",0,"/< The solid angle subtended by the PMT for this light path");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCosThetaAvg=",0,"/< Average incident angle on the PMT for this path.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFresnelTCoeff=",0,"/< The combined Fresnel TRANSMISSION coefficient for this path");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFresnelRCoeff=",0,"/< The combined Fresnel REFLECTIVITY coefficient for this path");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::PanelInfo */
static void G__setup_memvarRATcLcLDUcLcLPanelInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo));
   { RAT::DU::PanelInfo *p; p=(RAT::DU::PanelInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType),-1,-2,1,G__FastAllocString(2048).Format("S7=%lldLL",(long long)RAT::DU::PanelInfo::S7).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType),-1,-2,1,G__FastAllocString(2048).Format("S19=%lldLL",(long long)RAT::DU::PanelInfo::S19).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType),-1,-2,1,G__FastAllocString(2048).Format("T21=%lldLL",(long long)RAT::DU::PanelInfo::T21).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType),-1,-2,1,G__FastAllocString(2048).Format("T14=%lldLL",(long long)RAT::DU::PanelInfo::T14).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType),-1,-2,1,G__FastAllocString(2048).Format("T10=%lldLL",(long long)RAT::DU::PanelInfo::T10).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fPositions=",0,"/< The Panel positions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fDirections=",0,"/< The Panel Directions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR),G__defined_typename("vector<EPanelType>"),-1,4,"fTypes=",0,"/< The panel types");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fPanels=",0,"/< The panel panel numbers");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ChanHWStatus */
static void G__setup_memvarRATcLcLDUcLcLChanHWStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus));
   { RAT::DU::ChanHWStatus *p; p=(RAT::DU::ChanHWStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fDQCH=",0,"/< DQCH bits for each LCN");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fDQCR=",0,"/< DQCR bits for each LCN");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fDQXX=",0,"/< Combined DQXX bits for each LCN");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fDQID=",0,"/< Board IDs (MB, PMTIC, DBx4)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusN100=",0,"/< Mask of crates enabled for NHIT100 triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusN20=",0,"/< Mask of crates enabled for NHIT20 triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusELO=",0,"/< Mask of crates enabled for ESUM LO triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusEHI=",0,"/< Mask of crates enabled for ESUM HI triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusON=",0,"/< Mask of crates enabled for OWL NHIT triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusOELO=",0,"/< Mask of crates enabled for OWL ESUM LO triggers");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatusOEHI=",0,"/< Mask of crates enabled for OWL ESUM HI triggers");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskTubeOn=0LL",0,"/< SNO+ bit mask signifying a PMT being \"on\"");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskSNOTubeOn=0LL",0,"/< SNO bit mask signifying a PMT being \"on\"");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskDAQable=0LL",0,"/< SNO+ bit mask signifying a channel enabled in DAQ");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskSNODAQable=0LL",0,"/< SNO bit mask signifying a channel enabled in DAQ");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskTubeAtHV=0LL",0,"/< SNO+ bit mask signifying tube being at HV");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,-1,-2,4,"fMaskECAActive=0LL",0,"/< Check whether the channel can get data");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fConstantThreshold=",0,"/< Constant threshold value");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fSNO=",0,"/< True if CHS is in SNO mode (as specified by the ratdb).");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseConstantThreshold=",0,"/< True if a constant threshold should be used");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fEnabled=",0,"/< True if the channel hardware status information is enabled");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::PMTCalStatus */
static void G__setup_memvarRATcLcLDUcLcLPMTCalStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus));
   { RAT::DU::PMTCalStatus *p; p=(RAT::DU::PMTCalStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCHSBit=%lldLL",(long long)RAT::DU::PMTCalStatus::kCHSBit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kECABit=%lldLL",(long long)RAT::DU::PMTCalStatus::kECABit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kPCABit=%lldLL",(long long)RAT::DU::PMTCalStatus::kPCABit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kXTalkBit=%lldLL",(long long)RAT::DU::PMTCalStatus::kXTalkBit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kFlagBit=%lldLL",(long long)RAT::DU::PMTCalStatus::kFlagBit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCSSBit=%lldLL",(long long)RAT::DU::PMTCalStatus::kCSSBit).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fPdstMask=",0,"/ Cell-level mask applied to ECA_PDST[pdst_status]");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fTslpMask=",0,"/ Cell-level mask applied to ECA_TSLP[tslp_status]");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fTWMask=",0,"/ Channel-level mask applied to PCA_TW[PCATW_status]");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fECAHitMask=",0,"/ Hit-level mask applied to PMT->fStatus (first 32bits)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fPCAHitMask=",0,"/ Hit-level mask applied to PMT->fStatus (last 32bits)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fPdstStatus=",0,"/ Pedestal calibration status per cell");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fTslpStatus=",0,"/ TSlope calibration status per cell");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fTWStatus=",0,"/ Time walk calibration status per channel");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fPdstBoardID=",0,"/ Board ID used for pedestal calibration");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fTslpBoardID=",0,"/ Board ID used for tslope calibration");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fFlag=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"flagHits=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fChannelFlags=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ReactorNuOsc */
static void G__setup_memvarRATcLcLDUcLcLReactorNuOsc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc));
   { RAT::DU::ReactorNuOsc *p; p=(RAT::DU::ReactorNuOsc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR),G__defined_typename("DBLinkPtr"),-1,2,"fLink=",0,"for REACTORS.ratdb access");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fLatitude=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fLongitute=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fAltitude=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fOscProb=",0,"OscProbability() value");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fDmSqr21=",0,"oscillation parameter");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fDmSqr32=",0,"oscillation parameter");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSSqrTheta12=",0,"oscillation parameter");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSSqrTheta13=",0,"oscillation parameter");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSSqr2Theta12=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSSqr2Theta13=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fS4=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fC4=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ShadowingCalculator */
static void G__setup_memvarRATcLcLDUcLcLShadowingCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator));
   { RAT::DU::ShadowingCalculator *p; p=(RAT::DU::ShadowingCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAVHDRopeShadowFlag=",0,"/< TRUE: The light path intersected with AVHD rope position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBellyPlateShadowFlag=",0,"/< TRUE: The light path intersected with belly plate position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNCDAnchorShadowFlag=",0,"/< TRUE: The light path intersected with NCD anchor position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSupportRopeShadowFlag=",0,"/< TRUE: The light path intersected with support rope position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAVPipeShadowFlag=",0,"/< TRUE: The light path intersected with AV pipe position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNeckBossShadowFlag=",0,"/< TRUE: The light path intersected with the neck boss position coordinates FALSE: It didn't");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShadowFlag=",0,"/< TRUE: The light path intersected due to one of the above 4 geometry intersections FALSE: It didn't");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVHDRopeTolerance=",0,"/< Accepted tolerance/proxity to the AV hold-down ropes.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSupportRopeTolerance=",0,"/< Accepted tolerance/proxity to the support ropes.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBellyPlateTolerance=",0,"/< Accepted tolerance/proxity to the belly plates.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNCDAnchorTolerance=",0,"/< Accepted tolerance/proxity to the NCD anchors.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVPipeTolerance=",0,"/< Accepted tolerance/proxity to the AV pipes.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNeckBossTolerance=",0,"/< Accepted tolerance/proxity to the neck boss.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVInnerRadius=",0,"/< Inner radius of the AV.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVOuterRadius=",0,"/< Outer radius of the AV.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNeckOuterRadius=",0,"/< Outer radius of the AV neck.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistAVPipe=",0,"/< Whether or not AV pipes are in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipe1Points=",0,"/< Location of \"av_pipe-1\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipe2Points=",0,"/< Location of \"av_pipe-2\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipe3Points=",0,"/< Location of \"av_pipe-3\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipe4Points=",0,"/< Location of \"av_pipe-4\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipeLabSPoints=",0,"/< Location of \"av_pipe-labs\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipe6Points=",0,"/< Location of \"av_pipe-6\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipeLabRPoints=",0,"/< Location of \"av_pipe-labr\"");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVPipePoints=",0,"/< Location of all the AV pipes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVPipeXRadius=",0,"/< Radius of av_pipe-1,2,3,4 and 6");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVPipeLabXRadius=",0,"/< Radius of av_pipe-labs and av_pipe_labr");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistNCDAnchor=",0,"/< Whether or not NCD anchors are in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fNCDAnchorPoints=",0,"/< NCD Anchor Locations");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNCDAnchorHalfHeight=",0,"/< Half-height of an NCD anchor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNCDAnchorRadius=",0,"/< Radius of an NCD anchor");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistBellyPlate=",0,"/< Whether or not belly plates are in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fBellyPlateCentrePoints=",0,"/< Belly Plate Centre Locations");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fBellyPlatePoints=",0,"/< Belly Plate Locations");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBellyPlateHalfHeight=",0,"/< Half-height of an individual belly plate");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistAVHDRope=",0,"/< Whether or not AVHD ropes are in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVHDRopeSlingPoints=",0,"/< The points which define an individual sling, for which 10 slings form the hold down net");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fAVHDRopeSlingRolls=",0,"/< The angular displacement of each sling about the z-axis");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVHDRopeEquatorPoints=",0,"/< Points on the equator where the AVHD passes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVHDRopeUpperAVPoints=",0,"/< Points above the equator where the AV hold down ropes lay");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fAVHDRopeLowerAVPoints=",0,"/< Points below the equator where the AV hold down ropes lay");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAVHDRopeRadius=",0,"/< Radius of the AVHD Ropes");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistSupportRope=",0,"/< Whether or not support ropes are in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fSupportRopeEquatorPoints=",0,"/< Points on the equator where the support ropes loop through the belly plates");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fSupportRopeUpperAVPoints=",0,"/< Points above the AV equatow where the support ropes lay");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSupportRopeRadius=",0,"/< Radius of the support Ropes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSupportRopeHeight=",0,"/< The height of the support rope");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fExistNeckBoss=",0,"/< Whether or the neck boss is in the geometry (true: yes, false: no).");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNeckBossTheta=",0,"/< The theta position of the lower bevelled neck boss ring on the AV");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::Segmentor */
static void G__setup_memvarRATcLcLDUcLcLSegmentor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor));
   { RAT::DU::Segmentor *p; p=(RAT::DU::Segmentor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,4,"fSegmentIDs=",0,"/< Segment ID by PMT ID (LCN)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,4,"fPopulations=",0,"/< Count of online (tube and channel) PMTs in each segment");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNDivisions=",0,"/< The number of divisions to use");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPatternZaxis=",0,"/< Unit z-axis of the pattern");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPatternXaxis=",0,"/< Unit x-axis of the pattern");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPatternYaxis=",0,"/< Unit y-axis of the pattern");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-1,4,"fPatternOrigin=",0,"/< Pattern origin in SNO+ co-ordinates");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::SOCReader */
static void G__setup_memvarRATcLcLDUcLcLSOCReader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader));
   { RAT::DU::SOCReader *p; p=(RAT::DU::SOCReader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TChain),-1,-1,2,"fT=",0,"/< The DS T Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TChain),-1,-1,2,"fRunT=",0,"/< The DS runT Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC),-1,-1,2,"fSOC=",0,"/< The current event");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun),-1,-1,2,"fRun=",0,"/< The current run");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fCurrentSOC=",0,"/< The current event index");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fTotalSOC=",0,"/< The total number of events");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fCurrentRun=",0,"/< The current run index");
   G__memvar_setup((void*)0,109,0,0,-1,G__defined_typename("ULong64_t"),-1,2,"fTotalRuns=",0,"/< The total number of runs");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fUseMeta=",0,"/< Flag to use or ignore Meta information in file. Default true.");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ReconCorrector */
static void G__setup_memvarRATcLcLDUcLcLReconCorrector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector));
   { RAT::DU::ReconCorrector *p; p=(RAT::DU::ReconCorrector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fInitDone=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fMeVValuesOld1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fMeVValuesNew1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fPredictedNphotonsOld1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fPredictedNphotonsNew1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fMeVValuesOld2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fMeVValuesNew2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fPredictedNphotonsOld2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fPredictedNphotonsNew2=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::ReconCalibrator */
static void G__setup_memvarRATcLcLDUcLcLReconCalibrator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator));
   { RAT::DU::ReconCalibrator *p; p=(RAT::DU::ReconCalibrator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fInitDone=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fZoffsetAV=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRadiusAVOuterSqr=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsData1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsSim1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsData2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsSim2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsExtData2=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCoefficientsExtSim2=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::FitterPMT */
static void G__setup_memvarRATcLcLFitterPMT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   { RAT::FitterPMT *p; p=(RAT::FitterPMT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fID=",0,"/< The PMT channel number/id or lcn");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fCCCC=",0,"CCCC ( Crate Card Channel Cell number )");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fTime=",0,"/< The hit time or centroid");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fTimeError=",0,"/< Error associated with the hit time or centroid");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQHL=",0,"/< The hit QHL charge");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQHLError=",0,"/< Error associated with the QHL charge");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQHS=",0,"/< The hit QHS charge");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQHSError=",0,"/< Error associated with the QHS charge");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQLX=",0,"/< The hit QLX charge");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQLXError=",0,"/< Error associated with the QLX charge");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask),-1,-1,4,"fStatus=",0,"/< Status flags for the various calibrations");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fCrossTalkFlag=",0,"/< Crosstalk flag for each pmt hit");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::TimeResidualCalculator */
static void G__setup_memvarRATcLcLDUcLcLTimeResidualCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator));
   { RAT::DU::TimeResidualCalculator *p; p=(RAT::DU::TimeResidualCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPartialFlag=",0,"True if the calculator should use the partial fill calculation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator),-1,-1,4,"fLightPath=",0,"LightPathCalculator object for the calculator");
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::Utility */
static void G__setup_memvarRATcLcLDUcLcLUtility(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility));
   { RAT::DU::Utility *p; p=(RAT::DU::Utility*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo),-1,-1,4,"fPMTInfo=",0,"/< PMT Information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo),-1,-1,4,"fPanelInfo=",0,"/< Panel Information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus),-1,-1,4,"fChanHWStatus=",0,"/< Channel Hardware Status information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus),-1,-1,4,"fPMTCalStatus=",0,"/< PMTCal Status information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc),-1,-1,4,"fReactorNuOsc=",0,"/< Apply reactor anti-nu oscillations");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor),-1,-1,4,"fSegmentor=",0,"/< Segmentor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator),-1,-1,4,"fLightPathCalculator=",0,"/< Light Path information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity),-1,-1,4,"fGroupVelocity=",0,"/< Group Velocity information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity),-1,-1,4,"fEffectiveVelocity=",0,"/< Effective Velocity information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits),-1,-1,4,"fDataCleaningBits=",0,"/< Data cleaning bit mnemonics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits),-1,-1,4,"fDataQualityBits=",0,"/< Data quality bit mnemonics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus),-1,-1,4,"fChanSWStatus=",0,"/< Channel software status bit mnemonics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits),-1,-1,4,"fTrigBits=",0,"/< Data quality bit mnemonics");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator),-1,-1,4,"fShadowingCalculator=",0,"/< Shadowing utility");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector),-1,-1,4,"fReconCorrector=",0,"/< EnergyRSP correction");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator),-1,-1,4,"fReconCalibrator=",0,"/< Energy calibration functions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator),-1,-1,4,"fTimeResidualCalculator=",0,"/< Time residual functions");
   }
   G__tag_memvar_reset();
}


   /* RAT::TrackNode */
static void G__setup_memvarRATcLcLTrackNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode));
   { RAT::TrackNode *p; p=(RAT::TrackNode*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fChild)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR),G__defined_typename("vector<TrackNode*>"),-1,1,"fChild=",0,"Any additional tracks connected to this one");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fIsTrackStart=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fTrackID=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fStepID=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fPDGCode=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,2,"fParticleName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),-1,-1,2,"fPrev=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),-1,-1,2,"fNext=",0,"Next node for this same particle");
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > */
static void G__setup_memvarvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   { vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > *p; p=(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::TrackCursor */
static void G__setup_memvarRATcLcLTrackCursor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor));
   { RAT::TrackCursor *p; p=(RAT::TrackCursor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),-1,-1,2,"fCur=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fVerbose=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::TrackNav */
static void G__setup_memvarRATcLcLTrackNav(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav));
   { RAT::TrackNav *p; p=(RAT::TrackNav*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode),-1,-1,2,"fHead=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR),G__defined_typename("map<int,TrackNode*>"),-1,2,"fTracks=",0,"Access by Track ID");
   }
   G__tag_memvar_reset();
}


   /* RAT::DBCommandLoader */
static void G__setup_memvarRATcLcLDBCommandLoader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader));
   { RAT::DBCommandLoader *p; p=(RAT::DBCommandLoader*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DBTextLoader */
static void G__setup_memvarRATcLcLDBTextLoader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader));
   { RAT::DBTextLoader *p; p=(RAT::DBTextLoader*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::DBJsonLoader */
static void G__setup_memvarRATcLcLDBJsonLoader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader));
   { RAT::DBJsonLoader *p; p=(RAT::DBJsonLoader*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* RAT::HTTPDownloader */
static void G__setup_memvarRATcLcLHTTPDownloader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLHTTPDownloader));
   { RAT::HTTPDownloader *p; p=(RAT::HTTPDownloader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CURL"),-1,2,"handle=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"noproxy_set=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__defined_typename("ostringstream"),-1,2,"contents=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::MetaInformation */
static void G__setup_memvarRATcLcLMetaInformation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation));
   { RAT::MetaInformation *p; p=(RAT::MetaInformation*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta),-1,-1,2,"fMeta=",0,"The actual meta information");
   }
   G__tag_memvar_reset();
}


   /* PmtEventRecord */
static void G__setup_memvarPmtEventRecord(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord));
   { PmtEventRecord *p; p=(PmtEventRecord*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->DataType)-(long)(p)),114,0,0,-1,G__defined_typename("uint16_t"),-1,1,"DataType=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->PmtEventRecordInfo)-(long)(p)),114,0,0,-1,G__defined_typename("uint16_t"),-1,1,"PmtEventRecordInfo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->RunNumber)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"RunNumber=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->EvNumber)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"EvNumber=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->NPmtHit)-(long)(p)),114,0,0,-1,G__defined_typename("uint16_t"),-1,1,"NPmtHit=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->DaqStatus)-(long)(p)),114,0,0,-1,G__defined_typename("uint16_t"),-1,1,"DaqStatus=",0,"Now used to store sub-run number - PH");
   G__memvar_setup((void*)((long)(&p->CalPckType)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"CalPckType=",0,"lower 24 bits are now used for extended PmtEventRecord flags");
   G__memvar_setup((void*)((long)(&p->TriggerCardData)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData),G__defined_typename("aMTCReadoutData"),-1,1,"TriggerCardData=",0,"6 LW of MTC data");
   }
   G__tag_memvar_reset();
}


   /* RunRecord */
static void G__setup_memvarRunRecord(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RunRecord));
   { RunRecord *p; p=(RunRecord*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->Date)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Date=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->Time)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Time=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->SubRunNumber)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"SubRunNumber=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->RunNumber)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"RunNumber=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->CalibrationTrialNumber)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"CalibrationTrialNumber=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->SourceMask)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"SourceMask=",0,"which sources in?");
   G__memvar_setup((void*)((long)(&p->RunMask)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"RunMask=",0,"run conditions");
   G__memvar_setup((void*)((long)(&p->GTCrateMsk)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"GTCrateMsk=",0,"accommodate misspelling of this for backward compatibility");
   G__memvar_setup((void*)((long)(&p->FirstGTID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"FirstGTID=",0,"first GTID of this run");
   G__memvar_setup((void*)((long)(&p->ValidGTID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ValidGTID=",0,"first valid GTID (after hardware changes have been made)");
   G__memvar_setup((void*)((long)(&p->Spares)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Spares[8]=",0,"spares as per nick's suggestion (Thanks Nick!)");
   }
   G__tag_memvar_reset();
}


   /* TriggerInfo */
static void G__setup_memvarTriggerInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo));
   { TriggerInfo *p; p=(TriggerInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->TriggerMask)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"TriggerMask=",0,"which triggers were set?");
   G__memvar_setup((void*)((long)(&p->n100lo)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100lo=",0,"trigger Threshold settings");
   G__memvar_setup((void*)((long)(&p->n100med)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100med=",0,"these are longs cuz Josh is a weenie.");
   G__memvar_setup((void*)((long)(&p->n100hi)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100hi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n20)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n20=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n20lb)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n20lb=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->esumlo)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"esumlo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->esumhi)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"esumhi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owln)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owln=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owlelo)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owlelo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owlehi)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owlehi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n100lo_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100lo_zero=",0,"trigger Threshold zeroes");
   G__memvar_setup((void*)((long)(&p->n100med_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100med_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n100hi_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n100hi_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n20_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n20_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->n20lb_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"n20lb_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->esumlo_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"esumlo_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->esumhi_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"esumhi_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owln_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owln_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owlelo_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owlelo_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->owlehi_zero)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"owlehi_zero=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->PulserRate)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"PulserRate=",0,"MTC local pulser");
   G__memvar_setup((void*)((long)(&p->ControlRegister)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ControlRegister=",0,"MTC control register status");
   G__memvar_setup((void*)((long)(&p->reg_LockoutWidth)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"reg_LockoutWidth=",0,"min. time btwn global triggers");
   G__memvar_setup((void*)((long)(&p->reg_Prescale)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"reg_Prescale=",0,"how many nhit_100_lo triggers to take");
   G__memvar_setup((void*)((long)(&p->GTID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"GTID=",0,"to keep track of where I am in the world");
   }
   G__tag_memvar_reset();
}


   /* EpedRecord */
static void G__setup_memvarEpedRecord(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord));
   { EpedRecord *p; p=(EpedRecord*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->ped_width)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ped_width=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->ped_delay_coarse)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ped_delay_coarse=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->ped_delay_fine)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ped_delay_fine=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->qinj_dacsetting)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"qinj_dacsetting=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->halfCrateID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"halfCrateID=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->CalibrationType)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"CalibrationType=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->GTID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"GTID=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->Flag)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Flag=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ratzdab */
static void G__setup_memvarratzdab(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdab));
   {
   G__memvar_setup((void*)(&ratzdab::record_unknown),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error),-1,-2,1,"record_unknown=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ratzdab::unpack */
static void G__setup_memvarratzdabcLcLunpack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunpack));
   {
   }
   G__tag_memvar_reset();
}


   /* ratzdab::pack */
static void G__setup_memvarratzdabcLcLpack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLpack));
   {
   }
   G__tag_memvar_reset();
}


   /* ratzdab::unknown_record_error */
static void G__setup_memvarratzdabcLcLunknown_record_error(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error));
   { ratzdab::unknown_record_error *p; p=(ratzdab::unknown_record_error*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,1,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PZdabFile */
static void G__setup_memvarPZdabFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile));
   { PZdabFile *p; p=(PZdabFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->zfileeof)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_PZdabFilecLcLzdab_file_unexpected_eof),-1,-1,1,"zfileeof=",0,(char*)NULL);
   G__memvar_setup((void*)0,69,0,0,-1,-1,-1,2,"mFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mWordOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mBlockCount=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mRecordCount=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"mBufferEmpty=",0,(char*)NULL);
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mRecBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mRecBuffsize=",0,"size of temporary ZDAB buffer");
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mBuffPtr32=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mBytesRead=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mWordsTotal=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mBytesTotal=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,4,"mLastGTID=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_nZDAB),G__defined_typename("nZDAB"),-1,4,"mLastRecord=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ratzdab::zdabfile */
static void G__setup_memvarratzdabcLcLzdabfile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile));
   { ratzdab::zdabfile *p; p=(ratzdab::zdabfile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->zfileex)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error),-1,-1,1,"zfileex=",0,(char*)NULL);
   G__memvar_setup((void*)0,69,0,0,-1,-1,-1,2,"f=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile),-1,-1,2,"p=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ratzdab::zdabfile::zdab_file_read_error */
static void G__setup_memvarratzdabcLcLzdabfilecLcLzdab_file_read_error(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error));
   { ratzdab::zdabfile::zdab_file_read_error *p; p=(ratzdab::zdabfile::zdab_file_read_error*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,1,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ManipRopeStatus */
static void G__setup_memvarManipRopeStatus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus));
   { ManipRopeStatus *p; p=(ManipRopeStatus*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->ropeID)-(long)(p)),104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"ropeID=",0,"EManipulatorRopeID");
   G__memvar_setup((void*)((long)(&p->length)-(long)(p)),102,0,0,-1,-1,-1,1,"length=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->targetLength)-(long)(p)),102,0,0,-1,-1,-1,1,"targetLength=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->velocity)-(long)(p)),102,0,0,-1,-1,-1,1,"velocity=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->tension)-(long)(p)),102,0,0,-1,-1,-1,1,"tension=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->encoderError)-(long)(p)),102,0,0,-1,-1,-1,1,"encoderError=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->spares)-(long)(p)),102,0,0,-1,-1,-1,1,"spares[2]=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* MTCReadoutData */
static void G__setup_memvarMTCReadoutData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData));
   { MTCReadoutData *p; p=(MTCReadoutData*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Bc10_1 : 32=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Bc10_2 : 21=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Bc50_1 : 11=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"Bc50_2 : 32=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("uint32_t"),-1,1,"BcGT : 24=",0,"LSB");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Nhit_100_Lo : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Nhit_100_Med : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Nhit_100_Hi : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Nhit_20 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Nhit_20_LB : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"ESum_Lo : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"ESum_Hi : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Owln : 1=",0,"MSB");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Owle_Lo : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Owle_Hi : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Pulse_GT : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Prescale : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Pedestal : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Pong : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Sync : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_Async : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Hydrophone : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_3 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_4 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_5 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_6 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"NCD_Shaper : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Ext_8 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Special_Raw : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"NCD_Mux : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Soft_GT : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Miss_Trig : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Peak : 10=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Diff_1 : 3=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Diff_2 : 7=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Int : 10=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"TestGT : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Test50 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Test10 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"TestMem1 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"TestMem2 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"SynClr16 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"SynClr16_wo_TC16 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"SynClr24 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"SynClr24_wo_TC24 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"FIFOsNotAllEmpty : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"FIFOsNotAllFull : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"FIFOsAllFull : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Unused1 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Unused2 : 1=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,1,"Unused3 : 1=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::util */
static void G__setup_memvarRATcLcLutil(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLutil));
   {
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::EnergySystematics */
static void G__setup_memvarRATcLcLDUcLcLEnergySystematics(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics));
   { RAT::DU::EnergySystematics *p; p=(RAT::DU::EnergySystematics*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"resolution_uncertainty=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"energy_scale_systematic=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"reconstruction_smearing_factor=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::DU::Point3D */
static void G__setup_memvarRATcLcLDUcLcLPoint3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   { RAT::DU::Point3D *p; p=(RAT::DU::Point3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-2,4,"sDefined=",0,"bitmap: 1 if system defined");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-2,4,"sHasZ=",0,"bit map: 1 if non-zero z offset");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-2,4,"sValZ=",0,"location of origin in default system");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-2,4,"sName=",0,"name of coordinate system");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-2,4,"sDescription=",0,"short description");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-2,4,"sDefMothers=",0,"indices of mother volumes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-2,4,"sDefZOffsets=",0,"z offsets of mother volumes");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("size_t"),-1,4,"fSystem=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPos[3]=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::LP::LightPath */
static void G__setup_memvarRATcLcLLPcLcLLightPath(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath));
   { RAT::LP::LightPath *p; p=(RAT::LP::LightPath*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("Undefined=%lldLL",(long long)RAT::LP::LightPath::Undefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("InnerAV=%lldLL",(long long)RAT::LP::LightPath::InnerAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("UpperInnerAV=%lldLL",(long long)RAT::LP::LightPath::UpperInnerAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("LowerInnerAV=%lldLL",(long long)RAT::LP::LightPath::LowerInnerAV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("AV=%lldLL",(long long)RAT::LP::LightPath::AV).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("Neck=%lldLL",(long long)RAT::LP::LightPath::Neck).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("Water=%lldLL",(long long)RAT::LP::LightPath::Water).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType),-1,-2,1,G__FastAllocString(2048).Format("PMT=%lldLL",(long long)RAT::LP::LightPath::PMT).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fInnerAVRI=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fUpperTargetRI=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fLowerTargetRI=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fAVRI=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TGraph),-1,-2,4,"fWaterRI=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergy=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR),G__defined_typename("vector<RAT::DU::Point3D>"),-1,4,"fPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR),G__defined_typename("vector<TVector3>"),-1,4,"fDirection=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR),G__defined_typename("vector<RegionType>"),-1,4,"fRegionType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_string),-1,-1,4,"fFitter=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::LP::LightPathFitter */
static void G__setup_memvarRATcLcLLPcLcLLightPathFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter));
   { RAT::LP::LightPathFitter *p; p=(RAT::LP::LightPathFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::LP::LightPathStraightFitter */
static void G__setup_memvarRATcLcLLPcLcLLightPathStraightFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter));
   { RAT::LP::LightPathStraightFitter *p; p=(RAT::LP::LightPathStraightFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fNeckInnerRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fNeckOuterRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVInnerRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVOuterRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fPMTRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fFillZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("size_t"),-2,4,"fAVSystemId=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::LP::LightPathStraightScint */
static void G__setup_memvarRATcLcLLPcLcLLightPathStraightScint(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint));
   { RAT::LP::LightPathStraightScint *p; p=(RAT::LP::LightPathStraightScint*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-2,4,"fAV_offset=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAV_offset_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVRadiusOuter=",0,"outer radius, 6060 mm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVRadius=",0,"inner radius, 6005 mm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fBoundary=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fPSUPRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fPMTRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR),G__defined_typename("vector<RAT::DU::Point3D>"),-2,4,"pStart=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"distInTarget=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"distInWater=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"startPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"endPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"interPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"startVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"endVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"dirVec=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RAT::LP::LightPathStraightScintWater */
static void G__setup_memvarRATcLcLLPcLcLLightPathStraightScintWater(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater));
   { RAT::LP::LightPathStraightScintWater *p; p=(RAT::LP::LightPathStraightScintWater*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fFillLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-2,4,"fAV_offset=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAV_offset_z=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"fFillLevelCentre=",0,"center of fill level");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVRadiusOuter=",0,"outer radius, 6060 mm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fAVRadius=",0,"inner radius, 6005 mm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fNeckRadiusOuter=",0,"outer radius of neck");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fNeckRadius=",0,"inner radius of neck");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fBoundary=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fPSUPRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fZneckLo=",0,"bottom of the neck in z position");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fPMTRadius=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR),G__defined_typename("vector<RAT::DU::Point3D>"),-2,4,"pStart=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"distInUpperTarget=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"distInWater=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"startPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"endPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),-1,-2,4,"interPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"startVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"endVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RAT_DictLN_TVector3),-1,-2,4,"dirVec=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* map<string,string,less<string>,allocator<pair<const string,string> > > */
static void G__setup_memvarmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   { map<string,string,less<string>,allocator<pair<const string,string> > > *p; p=(map<string,string,less<string>,allocator<pair<const string,string> > >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::TrackNode,allocator<RAT::TrackNode> > */
static void G__setup_memvarvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   { vector<RAT::TrackNode,allocator<RAT::TrackNode> > *p; p=(vector<RAT::TrackNode,allocator<RAT::TrackNode> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<RAT::DBTable,allocator<RAT::DBTable> > */
static void G__setup_memvarvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   { vector<RAT::DBTable,allocator<RAT::DBTable> > *p; p=(vector<RAT::DBTable,allocator<RAT::DBTable> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarRAT_Dict() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncRAT(void) {
   /* RAT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RAT));
   G__memfunc_setup("to_ratdb_float_string",2234,G__RAT_Dict_168_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 0, "d - - 0 - value", (char*)NULL, (void*) G__func2void( (string (*)(double))(&RAT::to_ratdb_float_string) ), 0);
   G__memfunc_setup("to_ratdb_double_string",2335,G__RAT_Dict_168_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 0, "d - - 0 - value", (char*)NULL, (void*) G__func2void( (string (*)(double))(&RAT::to_ratdb_double_string) ), 0);
   G__memfunc_setup("escape_ratdb_string",2003,G__RAT_Dict_168_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - value", (char*)NULL, (void*) G__func2void( (string (*)(const string&))(&RAT::escape_ratdb_string) ), 0);
   G__memfunc_setup("TransformCoord",1459,G__RAT_Dict_168_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector2), -1, 0, 7, 1, 1, 0, 
"u 'TVector3' - 11 - V1 u 'TVector3' - 11 - V2 "
"u 'TVector3' - 11 - V3 u 'TVector2' - 11 - A1 "
"u 'TVector2' - 11 - A2 u 'TVector2' - 11 - A3 "
"u 'TVector3' - 11 - P", (char*)NULL, (void*) G__func2void( (TVector2 (*)(const TVector3&, const TVector3&, const TVector3&, const TVector2&, const TVector2&, const TVector2&, const TVector3&))(&RAT::TransformCoord) ), 0);
   G__memfunc_setup("SphereToIcosahedron",1945,G__RAT_Dict_168_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TVector3' - 1 - pointOnSphere u 'TVector2' - 1 - resultPosition "
"d - - 10 - totalLength d - - 10 - rotation", "Rotation: 0 for \"Phil\" style, 2.12 for \"SNO\" style", (void*) G__func2void( (void (*)(TVector3&, TVector2&, const double, const double))(&RAT::SphereToIcosahedron) ), 0);
   G__memfunc_setup("GetDataCleaningWord",1879,G__RAT_Dict_168_0_6, 109, -1, G__defined_typename("ULong64_t"), 0, 1, 1, 1, 0, "u 'string' - 11 - bitMask", (char*)NULL, (void*) G__func2void( (ULong64_t (*)(const string&))(&RAT::GetDataCleaningWord) ), 0);
   G__memfunc_setup("GetDataCleaningWord",1879,G__RAT_Dict_168_0_7, 109, -1, G__defined_typename("ULong64_t"), 0, 1, 1, 1, 0, "u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - cutnames", (char*)NULL, (void*) G__func2void( (ULong64_t (*)(const vector<std::string>&))(&RAT::GetDataCleaningWord) ), 0);
   G__memfunc_setup("EventIsClean",1185,G__RAT_Dict_168_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'RAT::DS::EV' - 11 - ev m - 'ULong64_t' 10 - dataCleaningWord "
"i - 'Int_t' 10 '-1' pass", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const RAT::DS::EV&, const ULong64_t, const Int_t))(&RAT::EventIsClean) ), 0);
   G__memfunc_setup("CheckMask",874,G__RAT_Dict_168_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'RAT::DS::BitMask' - 11 - bitMask m - 'ULong64_t' 10 - dataCleaningWord", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const RAT::DS::BitMask&, const ULong64_t))(&RAT::CheckMask) ), 0);
   G__memfunc_setup("MissingBits",1132,G__RAT_Dict_168_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RAT::DS::BitMask' - 11 - bitMask m - 'ULong64_t' 10 - dataCleaningWord", (char*)NULL, (void*) G__func2void( (void (*)(const RAT::DS::BitMask&, const ULong64_t))(&RAT::MissingBits) ), 0);
   G__memfunc_setup("SunDirection",1239,G__RAT_Dict_168_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 1, 0, 
"i - - 10 - UTdays i - - 10 - UTsecs "
"i - - 10 - UTnsecs d - - 10 '-49.58' labtwist", (char*)NULL, (void*) G__func2void( (TVector3 (*)(const int, const int, const int, const double))(&RAT::SunDirection) ), 0);
   G__memfunc_setup("GetRATVersion",1261,G__RAT_Dict_168_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) G__func2void( (const string (*)())(&RAT::GetRATVersion) ), 0);
   G__memfunc_setup("GetRATRevision",1366,G__RAT_Dict_168_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) G__func2void( (const string (*)())(&RAT::GetRATRevision) ), 0);
   G__memfunc_setup("QuadraticRoots",1461,G__RAT_Dict_168_0_14, 103, -1, -1, 0, 5, 1, 1, 0, 
"d - - 0 - a d - - 0 - b "
"d - - 0 - c d - - 1 - x1 "
"d - - 1 - x2", (char*)NULL, (void*) G__func2void( (bool (*)(double, double, double, double&, double&))(&RAT::QuadraticRoots) ), 0);
   G__memfunc_setup("SphericallyUniform3Vector",2566,G__RAT_Dict_168_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_CLHEPcLcLHep3Vector), G__defined_typename("G4ThreeVector"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (G4ThreeVector (*)())(&RAT::SphericallyUniform3Vector) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLBitMask(void) {
   /* RAT::DS::BitMask */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask));
   G__memfunc_setup("BitMask",683,G__RAT_Dict_170_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BitMask",683,G__RAT_Dict_170_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "m - 'ULong64_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__RAT_Dict_170_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - index g - 'Bool_t' 10 'true' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get",288,G__RAT_Dict_170_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBits",690,G__RAT_Dict_170_0_5, 109, -1, G__defined_typename("ULong64_t"), 0, 2, 1, 1, 8, 
"k - 'size_t' 10 - start k - 'size_t' 10 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetULong64_t",1090,G__RAT_Dict_170_0_6, 109, -1, G__defined_typename("ULong64_t"), 0, 1, 1, 1, 8, "k - 'size_t' 10 - startIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToString",826,G__RAT_Dict_170_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator~",1002,G__RAT_Dict_170_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator&",914,G__RAT_Dict_170_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 1, 1, 1, 8, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator&=",975,G__RAT_Dict_170_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator|",1000,G__RAT_Dict_170_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 1, 1, 1, 8, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator|=",1061,G__RAT_Dict_170_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator^",970,G__RAT_Dict_170_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 1, 1, 1, 8, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator^=",1031,G__RAT_Dict_170_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_170_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_170_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::BitMask' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator Bool_t",1515,G__RAT_Dict_170_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_170_0_18, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::BitMask::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_170_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::BitMask::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_170_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::BitMask::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_170_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::BitMask::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_170_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_170_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::BitMask::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_170_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::BitMask::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_170_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::BitMask::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_170_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::BitMask::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("BitMask", 683, G__RAT_Dict_170_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BitMask", 809, G__RAT_Dict_170_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_170_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLCalib(void) {
   /* RAT::DS::Calib */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib));
   G__memfunc_setup("Calib",475,G__RAT_Dict_224_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSourceName",1298,G__RAT_Dict_224_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSourceName",1310,G__RAT_Dict_224_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - _sourceName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetID",429,G__RAT_Dict_224_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetID",441,G__RAT_Dict_224_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - _id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,G__RAT_Dict_224_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMode",689,G__RAT_Dict_224_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - _mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntensity",1255,G__RAT_Dict_224_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntensity",1267,G__RAT_Dict_224_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - _intensity", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_224_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_224_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - _time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPos",594,G__RAT_Dict_224_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPos",606,G__RAT_Dict_224_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - _pos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDir",575,G__RAT_Dict_224_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDir",587,G__RAT_Dict_224_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - _dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__RAT_Dict_224_0_16, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::Calib::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_224_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Calib::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_224_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::Calib::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_224_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::Calib::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_224_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_224_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Calib::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_224_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Calib::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_224_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Calib::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_224_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Calib::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Calib", 475, G__RAT_Dict_224_0_28, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Calib' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Calib", 601, G__RAT_Dict_224_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_224_0_30, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::Calib' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLDataNotFound(void) {
   /* RAT::DS::DataNotFound */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound));
   G__memfunc_setup("DataNotFound",1191,G__RAT_Dict_238_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound), -1, 0, 3, 1, 1, 0, 
"u 'string' - 10 - className u 'string' - 10 - fieldName "
"u 'string' - 10 '\"\"' detail", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DataNotFound", 1191, G__RAT_Dict_238_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::DataNotFound' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DataNotFound", 1317, G__RAT_Dict_238_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_238_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::DataNotFound' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLClassifierResult(void) {
   /* RAT::DS::ClassifierResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult));
   G__memfunc_setup("ClassifierResult",1668,G__RAT_Dict_474_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__RAT_Dict_474_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClassification",1752,G__RAT_Dict_474_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name d - 'Double_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassification",1740,G__RAT_Dict_474_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassificationNames",2240,G__RAT_Dict_474_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValid",796,G__RAT_Dict_474_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValid",784,G__RAT_Dict_474_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExecutionTime",1647,G__RAT_Dict_474_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExecutionTime",1635,G__RAT_Dict_474_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFOM",526,G__RAT_Dict_474_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name d - 'Double_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFOM",514,G__RAT_Dict_474_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFOMNames",1014,G__RAT_Dict_474_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_474_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::ClassifierResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_474_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ClassifierResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_474_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::ClassifierResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_474_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::ClassifierResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_474_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_474_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ClassifierResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_474_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::ClassifierResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_474_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ClassifierResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_474_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::ClassifierResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ClassifierResult", 1668, G__RAT_Dict_474_0_25, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::ClassifierResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ClassifierResult", 1794, G__RAT_Dict_474_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_474_0_27, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::ClassifierResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLDataQCFlags(void) {
   /* RAT::DS::DataQCFlags */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags));
   G__memfunc_setup("DataQCFlags",1019,G__RAT_Dict_488_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExistFlags",1018,G__RAT_Dict_488_0_2, 103, -1, -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLatestPass",1316,G__RAT_Dict_488_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLatestPass",1316,G__RAT_Dict_488_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFlags",781,G__RAT_Dict_488_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFlags",781,G__RAT_Dict_488_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetApplied",991,G__RAT_Dict_488_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetApplied",991,G__RAT_Dict_488_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__RAT_Dict_488_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 10 - pass k - 'size_t' 10 - flag "
"g - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlags",793,G__RAT_Dict_488_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 10 - pass u 'RAT::DS::BitMask' - 11 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetApplied",1003,G__RAT_Dict_488_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 10 - pass u 'RAT::DS::BitMask' - 11 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_488_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::DataQCFlags::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_488_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::DataQCFlags::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_488_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::DataQCFlags::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_488_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::DataQCFlags::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_488_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_488_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::DataQCFlags::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_488_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::DataQCFlags::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_488_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::DataQCFlags::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_488_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::DataQCFlags::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("DataQCFlags", 1019, G__RAT_Dict_488_0_24, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::DataQCFlags' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DataQCFlags", 1145, G__RAT_Dict_488_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_488_0_26, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::DataQCFlags' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR(void) {
   /* map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR));
   G__memfunc_setup("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >",9723,G__RAT_Dict_493_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >",9723,G__RAT_Dict_493_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >",9723,G__RAT_Dict_493_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >",9723,G__RAT_Dict_493_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_493_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_493_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_493_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_493_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_493_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_493_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_493_0_11, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_493_0_12, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_493_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_493_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::BitMask>' 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_493_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - position u 'pair<unsigned int,RAT::DS::BitMask>' 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_493_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_493_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_493_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_493_0_19, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::size_type"), 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_493_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_493_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_493_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_493_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_493_0_24, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::size_type"), 0, 1, 1, 1, 8, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_493_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_493_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >", 9849, G__RAT_Dict_493_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR(void) {
   /* pair<unsigned int,RAT::DS::BitMask> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR));
   G__memfunc_setup("pair<unsigned int,RAT::DS::BitMask>",3115,G__RAT_Dict_494_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<unsigned int,RAT::DS::BitMask>",3115,G__RAT_Dict_494_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR), -1, 0, 2, 1, 1, 0, 
"h - - 11 - a u 'RAT::DS::BitMask' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR), -1, 1, 1, 1, 4, 0, "u 'pair<unsigned int,RAT::DS::BitMask>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<unsigned int,RAT::DS::BitMask>", 3115, G__RAT_Dict_494_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::BitMask>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<unsigned int,RAT::DS::BitMask>", 3241, G__RAT_Dict_494_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLDigitiser(void) {
   /* RAT::DS::Digitiser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser));
   G__memfunc_setup("Digitiser",932,G__RAT_Dict_498_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventID",943,G__RAT_Dict_498_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventID",955,G__RAT_Dict_498_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigTime",1093,G__RAT_Dict_498_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigTime",1105,G__RAT_Dict_498_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNWords",893,G__RAT_Dict_498_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNWords",905,G__RAT_Dict_498_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoardID",917,G__RAT_Dict_498_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoardID",929,G__RAT_Dict_498_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBit24",677,G__RAT_Dict_498_0_10, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBit24",689,G__RAT_Dict_498_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataFormat",1283,G__RAT_Dict_498_0_12, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataFormat",1295,G__RAT_Dict_498_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIOPins",850,G__RAT_Dict_498_0_14, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIOPins",862,G__RAT_Dict_498_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 10 - pins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExistsWaveform",1479,G__RAT_Dict_498_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "r - 'UShort_t' 10 - waveformID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaveform",1127,G__RAT_Dict_498_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR), G__defined_typename("vector<UShort_t>"), 0, 1, 1, 1, 8, "r - 'UShort_t' 10 - waveformID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWaveform",1139,G__RAT_Dict_498_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"r - 'UShort_t' 10 - waveformID u 'vector<unsigned short,allocator<unsigned short> >' 'vector<UShort_t>' 11 - samples", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllWaveforms",1523,G__RAT_Dict_498_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR), G__defined_typename("map<UShort_t,std::vector<UShort_t> >"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneWaveforms",1476,G__RAT_Dict_498_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Average",699,G__RAT_Dict_498_0_21, 100, -1, -1, 0, 3, 1, 1, 8, 
"r - 'UShort_t' 10 - waveformId k - 'size_t' 0 - start "
"k - 'size_t' 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integral",822,G__RAT_Dict_498_0_22, 100, -1, -1, 0, 3, 1, 1, 8, 
"r - 'UShort_t' 10 - waveformId k - 'size_t' 0 - start "
"k - 'size_t' 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,G__RAT_Dict_498_0_23, 114, -1, G__defined_typename("UShort_t"), 0, 3, 1, 1, 8, 
"r - 'UShort_t' 10 - waveformId k - 'size_t' 0 - start "
"k - 'size_t' 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Max",294,G__RAT_Dict_498_0_24, 114, -1, G__defined_typename("UShort_t"), 0, 3, 1, 1, 8, 
"r - 'UShort_t' 10 - waveformId k - 'size_t' 0 - start "
"k - 'size_t' 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIDs",544,G__RAT_Dict_498_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR), G__defined_typename("vector<UShort_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_498_0_26, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::Digitiser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_498_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Digitiser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_498_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::Digitiser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_498_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::Digitiser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_498_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_498_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Digitiser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_498_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Digitiser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_498_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Digitiser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_498_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Digitiser::DeclFileLine) ), 0);
   G__memfunc_setup("check_bounds",1256,(G__InterfaceMethod) NULL, 107, -1, G__defined_typename("size_t"), 0, 3, 1, 4, 8, 
"k - 'size_t' 0 - start k - 'size_t' 0 - end "
"k - 'size_t' 0 - alternate", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Digitiser", 932, G__RAT_Dict_498_0_39, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Digitiser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Digitiser", 1058, G__RAT_Dict_498_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_498_0_41, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::Digitiser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLECAHeader(void) {
   /* RAT::DS::ECAHeader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader));
   G__memfunc_setup("ECAHeader",786,G__RAT_Dict_508_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGTDelayCoarse",1543,G__RAT_Dict_508_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGTDelayCoarse",1555,G__RAT_Dict_508_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - delay", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGTDelayFine",1324,G__RAT_Dict_508_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGTDelayFine",1336,G__RAT_Dict_508_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - delay", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChargePedestalAmplitude",2625,G__RAT_Dict_508_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChargePedestalAmplitude",2637,G__RAT_Dict_508_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - amplitude", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChargePedestalWidth",2204,G__RAT_Dict_508_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChargePedestalWidth",2216,G__RAT_Dict_508_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPatternID",1163,G__RAT_Dict_508_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPatternID",1175,G__RAT_Dict_508_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalType",978,G__RAT_Dict_508_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCalType",990,G__RAT_Dict_508_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTSlopePoints",1602,G__RAT_Dict_508_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTSlopePoints",1614,G__RAT_Dict_508_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFlag",666,G__RAT_Dict_508_0_16, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlag",678,G__RAT_Dict_508_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_508_0_18, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::ECAHeader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_508_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ECAHeader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_508_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::ECAHeader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_508_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::ECAHeader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_508_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_508_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ECAHeader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_508_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::ECAHeader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_508_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::ECAHeader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_508_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::ECAHeader::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ECAHeader", 786, G__RAT_Dict_508_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::ECAHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ECAHeader", 912, G__RAT_Dict_508_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_508_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::ECAHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLUniversalTime(void) {
   /* RAT::DS::UniversalTime */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime));
   G__memfunc_setup("UniversalTime",1352,G__RAT_Dict_509_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UniversalTime",1352,G__RAT_Dict_509_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 10 - days_ h - 'UInt_t' 10 - seconds_ "
"h - 'UInt_t' 10 - nanoSeconds_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDays",689,G__RAT_Dict_509_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeconds",1007,G__RAT_Dict_509_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNanoSeconds",1403,G__RAT_Dict_509_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_509_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_tm), -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 10 'true' snoPlus", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__RAT_Dict_509_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__RAT_Dict_509_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__RAT_Dict_509_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__RAT_Dict_509_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_509_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_509_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__RAT_Dict_509_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,G__RAT_Dict_509_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>",938,G__RAT_Dict_509_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,G__RAT_Dict_509_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RAT::DS::UniversalTime' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_509_0_17, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::UniversalTime::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_509_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::UniversalTime::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_509_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::UniversalTime::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_509_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::UniversalTime::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_509_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_509_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::UniversalTime::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_509_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::UniversalTime::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_509_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::UniversalTime::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_509_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::UniversalTime::DeclFileLine) ), 0);
   G__memfunc_setup("Normalise",938,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("UniversalTime", 1352, G__RAT_Dict_509_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~UniversalTime", 1478, G__RAT_Dict_509_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_509_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>",8521,G__RAT_Dict_513_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>",8521,G__RAT_Dict_513_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Coordinates",1147,G__RAT_Dict_513_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR), -1, 0, 0, 5, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_513_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "D - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_513_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_513_0_6, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_513_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_513_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_513_0_9, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_513_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_513_0_11, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_513_0_12, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_513_0_13, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_513_0_14, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_513_0_15, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_513_0_16, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_513_0_17, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_513_0_18, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_513_0_19, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_513_0_20, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unit",416,G__RAT_Dict_513_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_513_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_513_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_513_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_513_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_513_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_513_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_513_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_513_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - etaval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__RAT_Dict_513_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__RAT_Dict_513_0_31, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_513_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__RAT_Dict_513_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__RAT_Dict_513_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/",923,G__RAT_Dict_513_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_513_0_36, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_513_0_37, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_513_0_38, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RAT_Dict_513_0_39, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RAT_Dict_513_0_40, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RAT_Dict_513_0_41, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__RAT_Dict_513_0_42, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rho",329,G__RAT_Dict_513_0_43, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mag2",359,G__RAT_Dict_513_0_44, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("perp2",489,G__RAT_Dict_513_0_45, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unit",448,G__RAT_Dict_513_0_46, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", 8521, G__RAT_Dict_513_0_47, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", 8647, G__RAT_Dict_513_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_513_0_49, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLCartesian3DlEfloatgR(void) {
   /* ROOT::Math::Cartesian3D<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR));
   G__memfunc_setup("Cartesian3D<float>",1697,G__RAT_Dict_514_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR), -1, 0, 0, 5, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cartesian3D<float>",1697,G__RAT_Dict_514_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR), -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - xx f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - yy "
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cartesian3D<float>",1697,G__RAT_Dict_514_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::Cartesian3D<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_514_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Cartesian3D<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_514_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'ROOT::Math::Cartesian3D<float>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_514_0_6, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_514_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - xx f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - yy "
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_514_0_8, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 1 - xx f - 'ROOT::Math::Cartesian3D<float>::Scalar' 1 - yy "
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 1 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_514_0_9, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_514_0_10, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_514_0_11, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_514_0_12, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_514_0_13, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_514_0_14, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_514_0_15, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_514_0_16, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_514_0_17, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_514_0_18, 102, -1, G__defined_typename("ROOT::Math::Cartesian3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_514_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_514_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_514_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_514_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - xx f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - yy "
"f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__RAT_Dict_514_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Negate",596,G__RAT_Dict_514_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_514_0_25, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::Cartesian3D<float>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_514_0_26, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::Cartesian3D<float>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_514_0_27, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_514_0_28, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_514_0_29, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_514_0_30, 121, -1, -1, 0, 1, 5, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_514_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_514_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_514_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_514_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Cartesian3D<float>::Scalar' 0 - eta", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Cartesian3D<float>", 1823, G__RAT_Dict_514_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>",8420,G__RAT_Dict_515_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 5, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>",8420,G__RAT_Dict_515_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Coordinates",1147,G__RAT_Dict_515_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR), -1, 0, 0, 5, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_515_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "F - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_515_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_515_0_6, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_515_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_515_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_515_0_9, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_515_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_515_0_11, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_515_0_12, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_515_0_13, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_515_0_14, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_515_0_15, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_515_0_16, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_515_0_17, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_515_0_18, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_515_0_19, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_515_0_20, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unit",416,G__RAT_Dict_515_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_515_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_515_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_515_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_515_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_515_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_515_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_515_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_515_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - etaval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__RAT_Dict_515_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__RAT_Dict_515_0_31, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_515_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__RAT_Dict_515_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__RAT_Dict_515_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/",923,G__RAT_Dict_515_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_515_0_36, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_515_0_37, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_515_0_38, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RAT_Dict_515_0_39, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RAT_Dict_515_0_40, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RAT_Dict_515_0_41, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__RAT_Dict_515_0_42, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rho",329,G__RAT_Dict_515_0_43, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mag2",359,G__RAT_Dict_515_0_44, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("perp2",489,G__RAT_Dict_515_0_45, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unit",448,G__RAT_Dict_515_0_46, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", 8420, G__RAT_Dict_515_0_47, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", 8546, G__RAT_Dict_515_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_515_0_49, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>",8109,G__RAT_Dict_521_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 5, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>",8109,G__RAT_Dict_521_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Coordinates",1147,G__RAT_Dict_521_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR), -1, 0, 0, 5, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_521_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "D - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_521_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_521_0_6, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_521_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_521_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_521_0_9, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_521_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_521_0_11, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_521_0_12, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_521_0_13, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_521_0_14, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_521_0_15, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_521_0_16, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_521_0_17, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_521_0_18, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_521_0_19, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_521_0_20, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unit",416,G__RAT_Dict_521_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_521_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_521_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_521_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_521_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_521_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_521_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_521_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_521_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - etaval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__RAT_Dict_521_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__RAT_Dict_521_0_31, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_521_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__RAT_Dict_521_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__RAT_Dict_521_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/",923,G__RAT_Dict_521_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "d - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_521_0_36, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_521_0_37, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_521_0_38, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RAT_Dict_521_0_39, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RAT_Dict_521_0_40, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RAT_Dict_521_0_41, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__RAT_Dict_521_0_42, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rho",329,G__RAT_Dict_521_0_43, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mag2",359,G__RAT_Dict_521_0_44, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("perp2",489,G__RAT_Dict_521_0_45, 100, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unit",448,G__RAT_Dict_521_0_46, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", 8109, G__RAT_Dict_521_0_47, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>", 8235, G__RAT_Dict_521_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_521_0_49, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLPolar3DlEfloatgR(void) {
   /* ROOT::Math::Polar3D<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR));
   G__memfunc_setup("Polar3D<float>",1285,G__RAT_Dict_522_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR), -1, 0, 0, 5, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Polar3D<float>",1285,G__RAT_Dict_522_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR), -1, 0, 3, 1, 1, 0, 
"f - - 0 - r f - - 0 - theta "
"f - - 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Polar3D<float>",1285,G__RAT_Dict_522_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::Polar3D<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_522_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Polar3D<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_522_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'ROOT::Math::Polar3D<float>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_522_0_6, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'ROOT::Math::Polar3D<float>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_522_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - r f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - theta "
"f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_522_0_8, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'ROOT::Math::Polar3D<float>::Scalar' 1 - r f - 'ROOT::Math::Polar3D<float>::Scalar' 1 - theta "
"f - 'ROOT::Math::Polar3D<float>::Scalar' 1 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_522_0_9, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_522_0_10, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_522_0_11, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_522_0_12, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_522_0_13, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_522_0_14, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_522_0_15, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_522_0_16, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_522_0_17, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_522_0_18, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_522_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_522_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 11 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_522_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 11 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_522_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - xx f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - yy "
"f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pi",217,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("ROOT::Math::Polar3D<float>::Scalar"), 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Restrict",848,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__RAT_Dict_522_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Negate",596,G__RAT_Dict_522_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_522_0_27, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::Polar3D<float>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_522_0_28, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::Polar3D<float>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_522_0_29, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_522_0_30, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_522_0_31, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_522_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_522_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_522_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_522_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_522_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'ROOT::Math::Polar3D<float>::Scalar' 0 - eta", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Polar3D<float>", 1411, G__RAT_Dict_522_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR(void) {
   /* ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR));
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>",8008,G__RAT_Dict_523_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 5, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>",8008,G__RAT_Dict_523_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Coordinates",1147,G__RAT_Dict_523_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR), -1, 0, 0, 5, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_523_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "F - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 10 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinates",1447,G__RAT_Dict_523_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_523_0_6, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 1 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinates",1435,G__RAT_Dict_523_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - dest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_523_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 3, 1, 1, 0, 
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - b "
"f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__RAT_Dict_523_0_9, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__RAT_Dict_523_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_523_0_11, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_523_0_12, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_523_0_13, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__RAT_Dict_523_0_14, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_523_0_15, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_523_0_16, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__RAT_Dict_523_0_17, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rho",297,G__RAT_Dict_523_0_18, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_523_0_19, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__RAT_Dict_523_0_20, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unit",416,G__RAT_Dict_523_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_523_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - xx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_523_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - yy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_523_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - zz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetR",382,G__RAT_Dict_523_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTheta",802,G__RAT_Dict_523_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__RAT_Dict_523_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRho",597,G__RAT_Dict_523_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - rr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__RAT_Dict_523_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - etaval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__RAT_Dict_523_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__RAT_Dict_523_0_31, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_523_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__RAT_Dict_523_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__RAT_Dict_523_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/",923,G__RAT_Dict_523_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 8, "f - 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("x",120,G__RAT_Dict_523_0_36, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("y",121,G__RAT_Dict_523_0_37, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("z",122,G__RAT_Dict_523_0_38, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("r",114,G__RAT_Dict_523_0_39, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("theta",534,G__RAT_Dict_523_0_40, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__RAT_Dict_523_0_41, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__RAT_Dict_523_0_42, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rho",329,G__RAT_Dict_523_0_43, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("mag2",359,G__RAT_Dict_523_0_44, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("perp2",489,G__RAT_Dict_523_0_45, 102, -1, G__defined_typename("ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>::Scalar"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unit",448,G__RAT_Dict_523_0_46, 117, G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", 8008, G__RAT_Dict_523_0_47, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>", 8134, G__RAT_Dict_523_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_523_0_49, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLFitVertex(void) {
   /* RAT::DS::FitVertex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex));
   G__memfunc_setup("FitVertex",929,G__RAT_Dict_539_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__RAT_Dict_539_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - pos g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositivePositionError",2526,G__RAT_Dict_539_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::XYZVectorF' 10 - posPosErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositivePositionError",2526,G__RAT_Dict_539_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::Polar3DVectorF' 10 - posPosErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativePositionError",2494,G__RAT_Dict_539_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::XYZVectorF' 10 - negPosErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativePositionError",2494,G__RAT_Dict_539_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::Polar3DVectorF' 10 - negPosErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositionErrors",1790,G__RAT_Dict_539_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::XYZVectorF' 10 - posErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositionErrors",1790,G__RAT_Dict_539_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>' 'ROOT::Math::Polar3DVectorF' 10 - posErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositionValid",1649,G__RAT_Dict_539_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositivePositionErrorValid",3022,G__RAT_Dict_539_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativePositionErrorValid",2990,G__RAT_Dict_539_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirection",1229,G__RAT_Dict_539_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - dir g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveDirectionError",2602,G__RAT_Dict_539_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - dirErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeDirectionError",2570,G__RAT_Dict_539_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - dirErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectionErrors",1866,G__RAT_Dict_539_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - dirErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectionValid",1725,G__RAT_Dict_539_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveDirectionErrorValid",3098,G__RAT_Dict_539_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeDirectionErrorValid",3066,G__RAT_Dict_539_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergy",918,G__RAT_Dict_539_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - energy_ g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveEnergyError",2291,G__RAT_Dict_539_0_20, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - energyErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeEnergyError",2259,G__RAT_Dict_539_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - energyErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergyErrors",1555,G__RAT_Dict_539_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 11 - energyErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergyValid",1414,G__RAT_Dict_539_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveEnergyErrorValid",2787,G__RAT_Dict_539_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeEnergyErrorValid",2755,G__RAT_Dict_539_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_539_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - time_ g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveTimeError",2072,G__RAT_Dict_539_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - timeErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeTimeError",2040,G__RAT_Dict_539_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - timeErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeErrors",1336,G__RAT_Dict_539_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 11 - timeErr g - 'Bool_t' 10 'true' valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeValid",1195,G__RAT_Dict_539_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositiveTimeErrorValid",2568,G__RAT_Dict_539_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNegativeTimeErrorValid",2536,G__RAT_Dict_539_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - valid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_539_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositivePositionError",2514,G__RAT_Dict_539_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNegativePositionError",2482,G__RAT_Dict_539_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__RAT_Dict_539_0_36, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositiveDirectionError",2590,G__RAT_Dict_539_0_37, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNegativeDirectionError",2558,G__RAT_Dict_539_0_38, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergy",906,G__RAT_Dict_539_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositiveEnergyError",2279,G__RAT_Dict_539_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNegativeEnergyError",2247,G__RAT_Dict_539_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_539_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositiveTimeError",2060,G__RAT_Dict_539_0_43, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNegativeTimeError",2028,G__RAT_Dict_539_0_44, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsPosition",1684,G__RAT_Dict_539_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsPositivePositionError",3057,G__RAT_Dict_539_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsNegativePositionError",3025,G__RAT_Dict_539_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsDirection",1760,G__RAT_Dict_539_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsPositiveDirectionError",3133,G__RAT_Dict_539_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsNegativeDirectionError",3101,G__RAT_Dict_539_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsEnergy",1449,G__RAT_Dict_539_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsPositiveEnergyError",2822,G__RAT_Dict_539_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsNegativeEnergyError",2790,G__RAT_Dict_539_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsTime",1230,G__RAT_Dict_539_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsPositiveTimeError",2603,G__RAT_Dict_539_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsNegativeTimeError",2571,G__RAT_Dict_539_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsAny",1127,G__RAT_Dict_539_0_57, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidPosition",1349,G__RAT_Dict_539_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidPositivePositionError",2722,G__RAT_Dict_539_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidNegativePositionError",2690,G__RAT_Dict_539_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidDirection",1425,G__RAT_Dict_539_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidPositiveDirectionError",2798,G__RAT_Dict_539_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidNegativeDirectionError",2766,G__RAT_Dict_539_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidEnergy",1114,G__RAT_Dict_539_0_64, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidPositiveEnergyError",2487,G__RAT_Dict_539_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidNegativeEnergyError",2455,G__RAT_Dict_539_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidTime",895,G__RAT_Dict_539_0_67, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidPositiveTimeError",2268,G__RAT_Dict_539_0_68, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidNegativeTimeError",2236,G__RAT_Dict_539_0_69, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValid",784,G__RAT_Dict_539_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidityMask",1522,G__RAT_Dict_539_0_71, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidUnfixed",1507,G__RAT_Dict_539_0_72, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedPosition",1349,G__RAT_Dict_539_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedPositivePositionError",2722,G__RAT_Dict_539_0_74, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedNegativePositionError",2690,G__RAT_Dict_539_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedDirection",1425,G__RAT_Dict_539_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedPositiveDirectionError",2798,G__RAT_Dict_539_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedNegativeDirectionError",2766,G__RAT_Dict_539_0_78, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedEnergy",1114,G__RAT_Dict_539_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedPositiveEnergyError",2487,G__RAT_Dict_539_0_80, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedNegativeEnergyError",2455,G__RAT_Dict_539_0_81, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedTime",895,G__RAT_Dict_539_0_82, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedPositiveTimeError",2268,G__RAT_Dict_539_0_83, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FixedNegativeTimeError",2236,G__RAT_Dict_539_0_84, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_539_0_85, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::FitVertex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_539_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitVertex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_539_0_87, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::FitVertex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_539_0_88, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::FitVertex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_539_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_539_0_93, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitVertex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_539_0_94, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitVertex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_539_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitVertex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_539_0_96, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitVertex::DeclFileLine) ), 0);
   G__memfunc_setup("SetMasks",811,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i 'RAT::DS::FitVertex::EMaskValues' - 10 - value g - 'Bool_t' 10 - valid "
"g - 'Bool_t' 10 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMask",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"h - 'UInt_t' 1 - mask i 'RAT::DS::FitVertex::EMaskValues' - 10 - bit "
"g - 'Bool_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FitVertex", 929, G__RAT_Dict_539_0_99, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::FitVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FitVertex", 1055, G__RAT_Dict_539_0_100, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_539_0_101, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::FitVertex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLFitResult(void) {
   /* RAT::DS::FitResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult));
   G__memfunc_setup("FitResult",930,G__RAT_Dict_542_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__RAT_Dict_542_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertex",938,G__RAT_Dict_542_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 10 - index u 'RAT::DS::FitVertex' - 11 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFOM",526,G__RAT_Dict_542_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name d - 'Double_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExecutionTime",1647,G__RAT_Dict_542_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertex",926,G__RAT_Dict_542_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertex",926,G__RAT_Dict_542_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertexCount",1447,G__RAT_Dict_542_0_8, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFOM",514,G__RAT_Dict_542_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFOMNames",1014,G__RAT_Dict_542_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExecutionTime",1635,G__RAT_Dict_542_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValid",784,G__RAT_Dict_542_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_542_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::FitResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_542_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_542_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::FitResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_542_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::FitResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_542_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_542_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_542_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_542_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_542_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("FitResult", 930, G__RAT_Dict_542_0_25, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::FitResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FitResult", 1056, G__RAT_Dict_542_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_542_0_27, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::FitResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR(void) {
   /* vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_546_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_546_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_546_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_546_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_546_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_546_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_546_0_7, 107, -1, G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_546_0_8, 107, -1, G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_546_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_546_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - sz u 'RAT::DS::FitVertex' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_546_0_11, 107, -1, G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_546_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_546_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_546_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), G__defined_typename("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >",5026,G__RAT_Dict_546_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >",5026,G__RAT_Dict_546_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n u 'RAT::DS::FitVertex' - 11 'RAT::DS::FitVertex()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >",5026,G__RAT_Dict_546_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >",5026,G__RAT_Dict_546_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator' 10 - first u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_546_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_546_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_546_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_546_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_546_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::FitVertex' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_546_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_546_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - position u 'RAT::DS::FitVertex' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_546_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - position u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_546_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - position k - 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::size_type' 0 - n "
"u 'RAT::DS::FitVertex' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_546_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_546_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_546_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - first u 'vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_546_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >", 5152, G__RAT_Dict_546_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR(void) {
   /* RAT::DS::FitClassifierCollection<RAT::DS::FitResult> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR));
   G__memfunc_setup("FitClassifierCollection<RAT::DS::FitResult>",4022,G__RAT_Dict_549_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNames",788,G__RAT_Dict_549_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResult",927,G__RAT_Dict_549_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResultExists",1279,G__RAT_Dict_549_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResult",939,G__RAT_Dict_549_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name u 'RAT::DS::FitResult' - 11 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneResult",1161,G__RAT_Dict_549_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_549_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_549_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_549_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_549_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_549_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_549_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_549_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_549_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_549_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::FitResult>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("FitClassifierCollection<RAT::DS::FitResult>", 4022, G__RAT_Dict_549_0_19, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::FitClassifierCollection<RAT::DS::FitResult>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FitClassifierCollection<RAT::DS::FitResult>", 4148, G__RAT_Dict_549_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_549_0_21, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::FitClassifierCollection<RAT::DS::FitResult>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR(void) {
   /* RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR));
   G__memfunc_setup("FitClassifierCollection<RAT::DS::ClassifierResult>",4760,G__RAT_Dict_558_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNames",788,G__RAT_Dict_558_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResult",927,G__RAT_Dict_558_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResultExists",1279,G__RAT_Dict_558_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResult",939,G__RAT_Dict_558_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name u 'RAT::DS::ClassifierResult' - 11 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneResult",1161,G__RAT_Dict_558_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_558_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_558_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_558_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_558_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_558_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_558_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_558_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_558_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_558_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("FitClassifierCollection<RAT::DS::ClassifierResult>", 4760, G__RAT_Dict_558_0_19, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FitClassifierCollection<RAT::DS::ClassifierResult>", 4886, G__RAT_Dict_558_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_558_0_21, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncjsoncLcLValue(void) {
   /* json::Value */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue));
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 1, 1, 0, "i 'json::Type' - 0 - type_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "l - 'json::TInteger' 0 - integer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "k - 'json::TUInteger' 0 - uinteger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_5, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "d - 'json::TReal' 0 - real", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_6, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "g - 'json::TBool' 0 - boolean", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_7, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "h - - 0 - uinteger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_8, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "i - - 0 - integer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_9, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "u 'string' 'json::TString' 0 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_10, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "u 'map<string,json::Value,less<string>,allocator<pair<const string,json::Value> > >' 'json::TObject' 0 - object", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_11, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 5, 1, 0, "u 'vector<json::Value,allocator<json::Value> >' 'json::TArray' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__RAT_Dict_683_0_12, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 1, 1, 0, "u 'json::Value' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_683_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 1, 1, 1, 0, "u 'json::Value' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_683_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 1, 1, 1, 8, "u 'string' - 11 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_683_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reset",547,G__RAT_Dict_683_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i 'json::Type' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reset",547,G__RAT_Dict_683_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getType",738,G__RAT_Dict_683_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getInteger",1038,G__RAT_Dict_683_0_19, 108, -1, G__defined_typename("json::TInteger"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getUInteger",1123,G__RAT_Dict_683_0_20, 107, -1, G__defined_typename("json::TUInteger"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getReal",708,G__RAT_Dict_683_0_21, 100, -1, G__defined_typename("json::TReal"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getBool",716,G__RAT_Dict_683_0_22, 103, -1, G__defined_typename("json::TBool"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getString",951,G__RAT_Dict_683_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), G__defined_typename("json::TString"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMember",920,G__RAT_Dict_683_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 1, 1, 1, 8, "u 'string' 'json::TString' 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getArraySize",1242,G__RAT_Dict_683_0_25, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getIndex",824,G__RAT_Dict_683_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 1, 1, 1, 8, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getMembers",1035,G__RAT_Dict_683_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMember",820,G__RAT_Dict_683_0_28, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 0 - key", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setInteger",1050,G__RAT_Dict_683_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'json::TInteger' 0 - integer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setUINteger",1103,G__RAT_Dict_683_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'json::TUInteger' 0 - uinteger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setReal",720,G__RAT_Dict_683_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'json::TReal' 0 - real", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setReal",720,G__RAT_Dict_683_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'json::TBool' 0 - boolean", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setString",963,G__RAT_Dict_683_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' 'json::TString' 0 - string", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setMember",932,G__RAT_Dict_683_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' 'json::TString' 0 - key u 'json::Value' - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setArraySize",1254,G__RAT_Dict_683_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'size_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setIndex",836,G__RAT_Dict_683_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - index u 'json::Value' - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("toJSONString",1172,G__RAT_Dict_683_0_37, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("prettyType",1098,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 2, 0, "i 'json::Type' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("wrongType",975,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"i 'json::Type' - 0 - actual i 'json::Type' - 0 - requested", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("checkType",928,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "i 'json::Type' - 0 - type_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("checkTypeReset",1443,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i 'json::Type' - 0 - type_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("decref",617,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("incref",631,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clean",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Value", 635, G__RAT_Dict_683_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLog(void) {
   /* RAT::Log */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog));
   G__memfunc_setup("Init",404,G__RAT_Dict_701_0_1, 103, -1, -1, 0, 3, 3, 1, 0, 
"u 'string' - 0 - _filename i 'RAT::Log::Level' - 0 'INFO' display "
"i 'RAT::Log::Level' - 0 'DETAIL' log", (char*)NULL, (void*) G__func2void( (bool (*)(string, RAT::Log::Level, RAT::Log::Level))(&RAT::Log::Init) ), 0);
   G__memfunc_setup("GetDisplayLevel",1518,G__RAT_Dict_701_0_2, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::Log::GetDisplayLevel) ), 0);
   G__memfunc_setup("GetG4DisplayLevel",1641,G__RAT_Dict_701_0_3, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::Log::GetG4DisplayLevel) ), 0);
   G__memfunc_setup("SetDisplayLevel",1530,G__RAT_Dict_701_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "i 'RAT::Log::Level' - 0 - level", (char*)NULL, (void*) G__func2void( (void (*)(RAT::Log::Level))(&RAT::Log::SetDisplayLevel) ), 0);
   G__memfunc_setup("GetLogLevel",1082,G__RAT_Dict_701_0_5, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::Log::GetLogLevel) ), 0);
   G__memfunc_setup("SetLogLevel",1094,G__RAT_Dict_701_0_6, 121, -1, -1, 0, 1, 3, 1, 0, "i 'RAT::Log::Level' - 0 - level", (char*)NULL, (void*) G__func2void( (void (*)(RAT::Log::Level))(&RAT::Log::SetLogLevel) ), 0);
   G__memfunc_setup("Die",274,G__RAT_Dict_701_0_7, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'string' - 0 - message i - - 0 '1' return_code", (char*)NULL, (void*) G__func2void( (void (*)(string, int))(&RAT::Log::Die) ), 0);
   G__memfunc_setup("Assert",626,G__RAT_Dict_701_0_8, 121, -1, -1, 0, 3, 3, 1, 0, 
"g - - 0 - condition u 'string' - 0 - message "
"i - - 0 '1' return_code", (char*)NULL, (void*) G__func2void( (void (*)(bool, string, int))(&RAT::Log::Assert) ), 0);
   G__memfunc_setup("GetLogBuffer",1180,G__RAT_Dict_701_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const string (*)())(&RAT::Log::GetLogBuffer) ), 0);
   G__memfunc_setup("AddMacro",763,G__RAT_Dict_701_0_10, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - contents", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&RAT::Log::AddMacro) ), 0);
   G__memfunc_setup("GetMacro",786,G__RAT_Dict_701_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const string& (*)())(&RAT::Log::GetMacro) ), 0);
   G__memfunc_setup("SetDBTraceState",1442,G__RAT_Dict_701_0_12, 121, -1, -1, 0, 1, 3, 1, 0, "g - - 0 'true' state", (char*)NULL, (void*) G__func2void( (void (*)(bool))(&RAT::Log::SetDBTraceState) ), 0);
   G__memfunc_setup("GetDBTraceState",1430,G__RAT_Dict_701_0_13, 103, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (bool (*)())(&RAT::Log::GetDBTraceState) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_14, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field i - - 0 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, int))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_15, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field f - - 0 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, float))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_16, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field d - - 0 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, double))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_17, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'string' - 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const string&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_18, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'vector<int,allocator<int> >' 'vector<int>' 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const vector<int>&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_19, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'vector<float,allocator<float> >' 'vector<float>' 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const vector<float>&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_20, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'vector<double,allocator<double> >' 'vector<double>' 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const vector<double>&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_21, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const vector<std::string>&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("TraceDBAccess",1223,G__RAT_Dict_701_0_22, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'string' - 11 - table u 'string' - 11 - index "
"u 'string' - 11 - field u 'json::Value' - 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&, const string&, const json::Value&))(&RAT::Log::TraceDBAccess) ), 0);
   G__memfunc_setup("GetDBTraceMap",1203,G__RAT_Dict_701_0_23, 85, G__get_linked_tagnum(&G__RAT_DictLN_TMap), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMap* (*)())(&RAT::Log::GetDBTraceMap) ), 0);
   G__memfunc_setup("ClearDBTraceMap",1402,G__RAT_Dict_701_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::Log::ClearDBTraceMap) ), 0);
   G__memfunc_setup("Log",290,G__RAT_Dict_701_0_25, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog), -1, 0, 1, 1, 1, 0, "U 'TRootIOCtor' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDBEntry",929,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"u 'string' - 11 - key u 'string' - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupIO",681,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearOMText",1064,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "U 'omtext' - 0 - out", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Log", 290, G__RAT_Dict_701_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog), -1, 0, 1, 1, 1, 0, "u 'RAT::Log' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Log", 416, G__RAT_Dict_701_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_701_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLog), -1, 1, 1, 1, 1, 0, "u 'RAT::Log' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLBitManip(void) {
   /* RAT::BitManip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip));
   G__memfunc_setup("BitManip",788,G__RAT_Dict_706_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCCC",489,G__RAT_Dict_706_0_2, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - lcn", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCCC) ), 0);
   G__memfunc_setup("GetCrate",783,G__RAT_Dict_706_0_3, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - lcn", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCrate) ), 0);
   G__memfunc_setup("GetChannel",985,G__RAT_Dict_706_0_4, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - lcn", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetChannel) ), 0);
   G__memfunc_setup("GetCard",666,G__RAT_Dict_706_0_5, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - lcn", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCard) ), 0);
   G__memfunc_setup("GetCCCC",556,G__RAT_Dict_706_0_6, 105, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - lcn i - - 0 - cell", (char*)NULL, (void*) G__func2void( (int (*)(int, int))(&RAT::BitManip::GetCCCC) ), 0);
   G__memfunc_setup("GetLCN",509,G__RAT_Dict_706_0_7, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetLCN) ), 0);
   G__memfunc_setup("GetLCN",509,G__RAT_Dict_706_0_8, 105, -1, -1, 0, 3, 3, 1, 0, 
"h - 'UInt_t' 0 - icrate h - 'UInt_t' 0 - icard "
"h - 'UInt_t' 0 - ichan", (char*)NULL, (void*) G__func2void( (int (*)(UInt_t, UInt_t, UInt_t))(&RAT::BitManip::GetLCN) ), 0);
   G__memfunc_setup("GetCell",672,G__RAT_Dict_706_0_9, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCell) ), 0);
   G__memfunc_setup("GetCCCwCell",992,G__RAT_Dict_706_0_10, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCCCwCell) ), 0);
   G__memfunc_setup("GetCratewCell",1286,G__RAT_Dict_706_0_11, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCratewCell) ), 0);
   G__memfunc_setup("GetChannelwCell",1488,G__RAT_Dict_706_0_12, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetChannelwCell) ), 0);
   G__memfunc_setup("GetCardwCell",1169,G__RAT_Dict_706_0_13, 105, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - cccc", (char*)NULL, (void*) G__func2void( (int (*)(int))(&RAT::BitManip::GetCardwCell) ), 0);
   G__memfunc_setup("GetBits",690,G__RAT_Dict_706_0_14, 105, -1, -1, 0, 3, 3, 1, 0, 
"i - - 0 - arg i - - 0 - loc "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (int (*)(int, int, int))(&RAT::BitManip::GetBits) ), 0);
   G__memfunc_setup("GetBits",690,G__RAT_Dict_706_0_15, 104, -1, G__defined_typename("UInt_t"), 0, 3, 3, 1, 0, 
"h - 'UInt_t' 0 - arg i - - 0 - loc "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (UInt_t (*)(UInt_t, int, int))(&RAT::BitManip::GetBits) ), 0);
   G__memfunc_setup("GetBits",690,G__RAT_Dict_706_0_16, 109, -1, G__defined_typename("ULong64_t"), 0, 3, 3, 1, 0, 
"m - 'ULong64_t' 0 - arg i - - 0 - loc "
"i - - 0 - n", (char*)NULL, (void*) G__func2void( (ULong64_t (*)(ULong64_t, int, int))(&RAT::BitManip::GetBits) ), 0);
   G__memfunc_setup("ClearBit",774,G__RAT_Dict_706_0_17, 105, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - arg i - - 0 - newbit", (char*)NULL, (void*) G__func2void( (int (*)(int, int))(&RAT::BitManip::ClearBit) ), 0);
   G__memfunc_setup("SetBit",587,G__RAT_Dict_706_0_18, 105, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - arg i - - 0 - newbit", (char*)NULL, (void*) G__func2void( (int (*)(int, int))(&RAT::BitManip::SetBit) ), 0);
   G__memfunc_setup("SetBit",587,G__RAT_Dict_706_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 2, 3, 1, 0, 
"u 'vector<int,allocator<int> >' 'vector<int>' 0 - arg i - - 0 - newbit", (char*)NULL, (void*) G__func2void( (vector<int> (*)(vector<int>, int))(&RAT::BitManip::SetBit) ), 0);
   G__memfunc_setup("SetBits",702,G__RAT_Dict_706_0_20, 105, -1, -1, 0, 3, 3, 1, 0, 
"i - - 0 - arg i - - 0 - loc "
"i - - 0 - val", "sets bits from (least sig) location loc in arg", (void*) G__func2void( (int (*)(int, int, int))(&RAT::BitManip::SetBits) ), 0);
   G__memfunc_setup("SetBit",587,G__RAT_Dict_706_0_21, 105, -1, -1, 0, 3, 3, 1, 0, 
"i - - 0 - arg i - - 0 - newbit "
"g - - 0 - test", (char*)NULL, (void*) G__func2void( (int (*)(int, int, bool))(&RAT::BitManip::SetBit) ), 0);
   G__memfunc_setup("SetBit",587,G__RAT_Dict_706_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 3, 3, 1, 0, 
"u 'vector<int,allocator<int> >' 'vector<int>' 0 - arg i - - 0 - newbit "
"g - - 0 - test", (char*)NULL, (void*) G__func2void( (vector<int> (*)(vector<int>, int, bool))(&RAT::BitManip::SetBit) ), 0);
   G__memfunc_setup("SetBits",702,G__RAT_Dict_706_0_23, 105, -1, -1, 0, 4, 3, 1, 0, 
"i - - 0 - arg i - - 0 - loc "
"i - - 0 - val g - - 0 - test", "sets bits from (least sig) location loc in arg", (void*) G__func2void( (int (*)(int, int, int, bool))(&RAT::BitManip::SetBits) ), 0);
   G__memfunc_setup("TestBit",703,G__RAT_Dict_706_0_24, 103, -1, -1, 0, 2, 3, 1, 0, 
"h - - 0 - word i - - 0 - bit", (char*)NULL, (void*) G__func2void( (bool (*)(unsigned int, int))(&RAT::BitManip::TestBit) ), 0);
   G__memfunc_setup("TestBit",703,G__RAT_Dict_706_0_25, 103, -1, -1, 0, 2, 3, 1, 0, 
"u 'vector<int,allocator<int> >' 'vector<int>' 0 - word i - - 0 - bit", (char*)NULL, (void*) G__func2void( (bool (*)(vector<int>, int))(&RAT::BitManip::TestBit) ), 0);
   G__memfunc_setup("TestBit",703,G__RAT_Dict_706_0_26, 103, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - word i - - 0 - bit", (char*)NULL, (void*) G__func2void( (bool (*)(int, int))(&RAT::BitManip::TestBit) ), 0);
   G__memfunc_setup("AndWords",802,G__RAT_Dict_706_0_27, 105, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - BitManip i - - 0 - mask", "Bitwise & of the arguments", (void*) G__func2void( (int (*)(int, int))(&RAT::BitManip::AndWords) ), 0);
   G__memfunc_setup("TestMask",812,G__RAT_Dict_706_0_28, 103, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - BitManip i - - 0 - mask", "Logical test of BitManip against mask", (void*) G__func2void( (bool (*)(int, int))(&RAT::BitManip::TestMask) ), 0);
   G__memfunc_setup("FlipBit",682,G__RAT_Dict_706_0_29, 104, -1, -1, 0, 2, 3, 1, 0, 
"h - - 0 - arg i - - 0 - bit", (char*)NULL, (void*) G__func2void( (unsigned int (*)(unsigned int, int))(&RAT::BitManip::FlipBit) ), 0);
   G__memfunc_setup("FlipBit",682,G__RAT_Dict_706_0_30, 114, -1, -1, 0, 2, 3, 1, 0, 
"r - - 0 - arg i - - 0 - bit", (char*)NULL, (void*) G__func2void( (unsigned short (*)(unsigned short, int))(&RAT::BitManip::FlipBit) ), 0);
   G__memfunc_setup("CopyFlipBit",1093,G__RAT_Dict_706_0_31, 121, -1, -1, 0, 4, 3, 1, 0, 
"i - - 0 - word i - - 0 - bit "
"i - - 1 - arg i - - 0 - newbit", "test bit in word and set newbit in arg", (void*) G__func2void( (void (*)(int, int, int&, int))(&RAT::BitManip::CopyFlipBit) ), 0);
   G__memfunc_setup("CopyFlipSameBit",1483,G__RAT_Dict_706_0_32, 121, -1, -1, 0, 3, 3, 1, 0, 
"i - - 0 - word i - - 1 - arg "
"i - - 0 - newbit", "test bit in word and set newbit in arg", (void*) G__func2void( (void (*)(int, int&, int))(&RAT::BitManip::CopyFlipSameBit) ), 0);
   G__memfunc_setup("CheckLength",1088,G__RAT_Dict_706_0_33, 103, -1, -1, 0, 2, 3, 1, 0, 
"i - - 0 - arg i - - 0 - length", (char*)NULL, (void*) G__func2void( (bool (*)(int, int))(&RAT::BitManip::CheckLength) ), 0);
   G__memfunc_setup("CheckLength",1088,G__RAT_Dict_706_0_34, 103, -1, -1, 0, 2, 3, 1, 0, 
"h - 'UInt_t' 0 - arg i - - 0 - length", (char*)NULL, (void*) G__func2void( (bool (*)(UInt_t, int))(&RAT::BitManip::CheckLength) ), 0);
   // automatic copy constructor
   G__memfunc_setup("BitManip", 788, G__RAT_Dict_706_0_35, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip), -1, 0, 1, 1, 1, 0, "u 'RAT::BitManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BitManip", 914, G__RAT_Dict_706_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_706_0_37, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLBitManip), -1, 1, 1, 1, 1, 0, "u 'RAT::BitManip' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTCal(void) {
   /* RAT::DS::PMTCal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal));
   G__memfunc_setup("PMTCal",513,G__RAT_Dict_707_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__RAT_Dict_707_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__RAT_Dict_707_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatus",944,G__RAT_Dict_707_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::BitMask' - 11 - status_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPMTParameters",1585,G__RAT_Dict_707_0_5, 121, -1, -1, 0, 8, 1, 1, 0, 
"h - 'UInt_t' 10 - _id d - 'Double_t' 10 - _qhs "
"d - 'Double_t' 10 - _qhl d - 'Double_t' 10 - _qlx "
"d - 'Double_t' 10 - _time r - 'UShort_t' 10 - _cellID "
"c - 'Char_t' 10 - flags u 'RAT::DS::BitMask' - 11 - status_", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__RAT_Dict_707_0_6, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMTCal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_707_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTCal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_707_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMTCal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_707_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMTCal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_707_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_707_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTCal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_707_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTCal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_707_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTCal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_707_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTCal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMTCal", 513, G__RAT_Dict_707_0_18, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTCal", 639, G__RAT_Dict_707_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_707_0_20, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTlEDouble32_tgR(void) {
   /* RAT::DS::PMT<Double32_t> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR));
   G__memfunc_setup("PMT<Double32_t>",1278,G__RAT_Dict_708_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__RAT_Dict_708_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogicalChannelNumber",2301,G__RAT_Dict_708_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLCN",509,G__RAT_Dict_708_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCardCrateChannel",1858,G__RAT_Dict_708_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCCC",489,G__RAT_Dict_708_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrateCardChannelCell",2242,G__RAT_Dict_708_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCCCC",556,G__RAT_Dict_708_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrate",783,G__RAT_Dict_708_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCard",666,G__RAT_Dict_708_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChannel",985,G__RAT_Dict_708_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetID",441,G__RAT_Dict_708_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - _id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQHS",524,G__RAT_Dict_708_0_13, 100, -1, G__defined_typename("Double32_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQHS",536,G__RAT_Dict_708_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double32_t' 10 - _qhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQHL",517,G__RAT_Dict_708_0_15, 100, -1, G__defined_typename("Double32_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQHL",529,G__RAT_Dict_708_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double32_t' 10 - _qhl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQLX",533,G__RAT_Dict_708_0_17, 100, -1, G__defined_typename("Double32_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQLX",545,G__RAT_Dict_708_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double32_t' 10 - _qlx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_708_0_19, 100, -1, G__defined_typename("Double32_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_708_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double32_t' 10 - _time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellID",813,G__RAT_Dict_708_0_21, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCellID",825,G__RAT_Dict_708_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 10 - _cellID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChanFlags",1159,G__RAT_Dict_708_0_23, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChanFlags",1171,G__RAT_Dict_708_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 10 - _channelFlags", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrossTalkFlag",1584,G__RAT_Dict_708_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCrossTalkFlag",1596,G__RAT_Dict_708_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - crosstalk", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPMTParameters",1585,G__RAT_Dict_708_0_27, 121, -1, -1, 0, 7, 1, 1, 0, 
"h - 'UInt_t' 10 - _id d - 'Double32_t' 10 - _qhs "
"d - 'Double32_t' 10 - _qhl d - 'Double32_t' 10 - _qlx "
"d - 'Double32_t' 10 - _time r - 'UShort_t' 10 - _cellID "
"c - 'Char_t' 10 - flags", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__RAT_Dict_708_0_28, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMT<Double32_t>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_708_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<Double32_t>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_708_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMT<Double32_t>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_708_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMT<Double32_t>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_708_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_708_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<Double32_t>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_708_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMT<Double32_t>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_708_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<Double32_t>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_708_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMT<Double32_t>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMT<Double32_t>", 1278, G__RAT_Dict_708_0_40, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<Double32_t>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMT<Double32_t>", 1404, G__RAT_Dict_708_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_708_0_42, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMT<Double32_t>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTlEunsignedsPshortgR(void) {
   /* RAT::DS::PMT<unsigned short> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR));
   G__memfunc_setup("PMT<unsigned short>",1816,G__RAT_Dict_709_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__RAT_Dict_709_0_2, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogicalChannelNumber",2301,G__RAT_Dict_709_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLCN",509,G__RAT_Dict_709_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCardCrateChannel",1858,G__RAT_Dict_709_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCCC",489,G__RAT_Dict_709_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrateCardChannelCell",2242,G__RAT_Dict_709_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCCCC",556,G__RAT_Dict_709_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrate",783,G__RAT_Dict_709_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCard",666,G__RAT_Dict_709_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChannel",985,G__RAT_Dict_709_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetID",441,G__RAT_Dict_709_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - _id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQHS",524,G__RAT_Dict_709_0_13, 114, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQHS",536,G__RAT_Dict_709_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "r - - 10 - _qhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQHL",517,G__RAT_Dict_709_0_15, 114, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQHL",529,G__RAT_Dict_709_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "r - - 10 - _qhl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQLX",533,G__RAT_Dict_709_0_17, 114, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetQLX",545,G__RAT_Dict_709_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "r - - 10 - _qlx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_709_0_19, 114, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_709_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "r - - 10 - _time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellID",813,G__RAT_Dict_709_0_21, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCellID",825,G__RAT_Dict_709_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 10 - _cellID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChanFlags",1159,G__RAT_Dict_709_0_23, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChanFlags",1171,G__RAT_Dict_709_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 10 - _channelFlags", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCrossTalkFlag",1584,G__RAT_Dict_709_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCrossTalkFlag",1596,G__RAT_Dict_709_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - crosstalk", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPMTParameters",1585,G__RAT_Dict_709_0_27, 121, -1, -1, 0, 7, 1, 1, 0, 
"h - 'UInt_t' 10 - _id r - - 10 - _qhs "
"r - - 10 - _qhl r - - 10 - _qlx "
"r - - 10 - _time r - 'UShort_t' 10 - _cellID "
"c - 'Char_t' 10 - flags", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__RAT_Dict_709_0_28, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMT<unsigned short>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_709_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<unsigned short>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_709_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMT<unsigned short>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_709_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMT<unsigned short>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_709_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_709_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<unsigned short>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_709_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMT<unsigned short>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_709_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMT<unsigned short>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_709_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMT<unsigned short>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMT<unsigned short>", 1816, G__RAT_Dict_709_0_40, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMT<unsigned short>", 1942, G__RAT_Dict_709_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_709_0_42, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCHit(void) {
   /* RAT::DS::MCHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit));
   G__memfunc_setup("MCHit",437,G__RAT_Dict_710_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_710_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_710_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_710_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_710_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_710_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_710_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_710_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_710_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_710_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCHit", 437, G__RAT_Dict_710_0_14, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCHit", 563, G__RAT_Dict_710_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_710_0_16, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLPMTInfo(void) {
   /* RAT::DU::PMTInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_712_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__RAT_Dict_712_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPetalStatus",1434,G__RAT_Dict_712_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPanelNumber",1401,G__RAT_Dict_712_0_4, 105, -1, -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_712_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__RAT_Dict_712_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__RAT_Dict_712_0_7, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_712_0_8, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::PMTInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_712_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_712_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::PMTInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_712_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::PMTInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_712_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_712_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_712_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PMTInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_712_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_712_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PMTInfo::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("PMTInfo", 637, G__RAT_Dict_712_0_20, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("PMTInfo", 637, G__RAT_Dict_712_0_21, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::PMTInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTInfo", 763, G__RAT_Dict_712_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_712_0_23, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::PMTInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR(void) {
   /* RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR));
   G__memfunc_setup("PMTSet<RAT::DS::PMT<unsigned short> >",3125,G__RAT_Dict_727_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Combine",701,G__RAT_Dict_727_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >' - 11 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_727_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_727_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_727_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_727_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_727_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_727_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_727_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_727_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_727_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_727_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_727_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_727_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_727_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_727_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_727_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_727_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_727_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_727_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_727_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_727_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_727_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_727_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllCount",1090,G__RAT_Dict_727_0_25, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__RAT_Dict_727_0_26, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalCount",1426,G__RAT_Dict_727_0_27, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLCount",1051,G__RAT_Dict_727_0_28, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainCount",1498,G__RAT_Dict_727_0_29, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTCount",1128,G__RAT_Dict_727_0_30, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckCount",1194,G__RAT_Dict_727_0_31, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDCount",1083,G__RAT_Dict_727_0_32, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpareCount",1316,G__RAT_Dict_727_0_33, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQECount",1031,G__RAT_Dict_727_0_34, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidCount",1520,G__RAT_Dict_727_0_35, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPMT",506,G__RAT_Dict_727_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RAT::DS::PMT<unsigned short>' - 11 - pmt i 'RAT::DU::PMTInfo::EPMTType' - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNormalPMT",1123,G__RAT_Dict_727_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOWLPMT",748,G__RAT_Dict_727_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLowGainPMT",1195,G__RAT_Dict_727_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBUTTPMT",825,G__RAT_Dict_727_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNeckPMT",891,G__RAT_Dict_727_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFECDPMT",780,G__RAT_Dict_727_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSparePMT",1013,G__RAT_Dict_727_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHQEPMT",728,G__RAT_Dict_727_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInvalidPMT",1217,G__RAT_Dict_727_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMT<unsigned short>' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneAllPMTs",1159,G__RAT_Dict_727_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNormalPMTs",1495,G__RAT_Dict_727_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInwardPMTs",1491,G__RAT_Dict_727_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneOWLPMTs",1120,G__RAT_Dict_727_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneLowGainPMTs",1567,G__RAT_Dict_727_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneBUTTPMTs",1197,G__RAT_Dict_727_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNeckPMTs",1263,G__RAT_Dict_727_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneFECDPMTs",1152,G__RAT_Dict_727_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneSparePMTs",1385,G__RAT_Dict_727_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneHQEPMTs",1100,G__RAT_Dict_727_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInvalidPMTs",1589,G__RAT_Dict_727_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_727_0_57, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_727_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_727_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_727_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_727_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_727_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_727_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_727_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_727_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMTSet<RAT::DS::PMT<unsigned short> >", 3125, G__RAT_Dict_727_0_69, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTSet<RAT::DS::PMT<unsigned short> >", 3251, G__RAT_Dict_727_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_727_0_71, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR(void) {
   /* RAT::DS::PMTSet<RAT::DS::PMTCal> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR));
   G__memfunc_setup("PMTSet<RAT::DS::PMTCal>",1790,G__RAT_Dict_732_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Combine",701,G__RAT_Dict_732_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMTCal>' - 11 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_732_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_732_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_732_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_732_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_732_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_732_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_732_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_732_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_732_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_732_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_732_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_732_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_732_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_732_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_732_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_732_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_732_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_732_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_732_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_732_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_732_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_732_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllCount",1090,G__RAT_Dict_732_0_25, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__RAT_Dict_732_0_26, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalCount",1426,G__RAT_Dict_732_0_27, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLCount",1051,G__RAT_Dict_732_0_28, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainCount",1498,G__RAT_Dict_732_0_29, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTCount",1128,G__RAT_Dict_732_0_30, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckCount",1194,G__RAT_Dict_732_0_31, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDCount",1083,G__RAT_Dict_732_0_32, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpareCount",1316,G__RAT_Dict_732_0_33, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQECount",1031,G__RAT_Dict_732_0_34, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidCount",1520,G__RAT_Dict_732_0_35, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPMT",506,G__RAT_Dict_732_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RAT::DS::PMTCal' - 11 - pmt i 'RAT::DU::PMTInfo::EPMTType' - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNormalPMT",1123,G__RAT_Dict_732_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOWLPMT",748,G__RAT_Dict_732_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLowGainPMT",1195,G__RAT_Dict_732_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBUTTPMT",825,G__RAT_Dict_732_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNeckPMT",891,G__RAT_Dict_732_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFECDPMT",780,G__RAT_Dict_732_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSparePMT",1013,G__RAT_Dict_732_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHQEPMT",728,G__RAT_Dict_732_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInvalidPMT",1217,G__RAT_Dict_732_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneAllPMTs",1159,G__RAT_Dict_732_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNormalPMTs",1495,G__RAT_Dict_732_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInwardPMTs",1491,G__RAT_Dict_732_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneOWLPMTs",1120,G__RAT_Dict_732_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneLowGainPMTs",1567,G__RAT_Dict_732_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneBUTTPMTs",1197,G__RAT_Dict_732_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNeckPMTs",1263,G__RAT_Dict_732_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneFECDPMTs",1152,G__RAT_Dict_732_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneSparePMTs",1385,G__RAT_Dict_732_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneHQEPMTs",1100,G__RAT_Dict_732_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInvalidPMTs",1589,G__RAT_Dict_732_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_732_0_57, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_732_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_732_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_732_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_732_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_732_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_732_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_732_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_732_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::PMTCal>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMTSet<RAT::DS::PMTCal>", 1790, G__RAT_Dict_732_0_69, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMTCal>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTSet<RAT::DS::PMTCal>", 1916, G__RAT_Dict_732_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_732_0_71, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::PMTCal>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR(void) {
   /* vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_734_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_734_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_734_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_734_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_734_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_734_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_734_0_7, 107, -1, G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_734_0_8, 107, -1, G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_734_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_734_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - sz u 'RAT::DS::PMTCal' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_734_0_11, 107, -1, G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_734_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_734_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_734_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), G__defined_typename("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >",4194,G__RAT_Dict_734_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >",4194,G__RAT_Dict_734_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n u 'RAT::DS::PMTCal' - 11 'RAT::DS::PMTCal()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >",4194,G__RAT_Dict_734_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >",4194,G__RAT_Dict_734_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator' 10 - first u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_734_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_734_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_734_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_734_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTCal), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_734_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_734_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_734_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - position u 'RAT::DS::PMTCal' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_734_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - position u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_734_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - position k - 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::size_type' 0 - n "
"u 'RAT::DS::PMTCal' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_734_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_734_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_734_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - first u 'vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_734_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >", 4320, G__RAT_Dict_734_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR(void) {
   /* RAT::DS::PMTSet<RAT::DS::MCHit> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR));
   G__memfunc_setup("PMTSet<RAT::DS::MCHit>",1714,G__RAT_Dict_737_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Combine",701,G__RAT_Dict_737_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::MCHit>' - 11 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_737_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllPMT",810,G__RAT_Dict_737_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_737_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMT",529,G__RAT_Dict_737_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_737_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalPMT",1146,G__RAT_Dict_737_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_737_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLPMT",771,G__RAT_Dict_737_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_737_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainPMT",1218,G__RAT_Dict_737_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_737_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTPMT",848,G__RAT_Dict_737_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_737_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckPMT",914,G__RAT_Dict_737_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_737_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDPMT",803,G__RAT_Dict_737_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_737_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSparePMT",1036,G__RAT_Dict_737_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_737_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQEPMT",751,G__RAT_Dict_737_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_737_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidPMT",1240,G__RAT_Dict_737_0_24, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCHit), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllCount",1090,G__RAT_Dict_737_0_25, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__RAT_Dict_737_0_26, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalCount",1426,G__RAT_Dict_737_0_27, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOWLCount",1051,G__RAT_Dict_737_0_28, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowGainCount",1498,G__RAT_Dict_737_0_29, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBUTTCount",1128,G__RAT_Dict_737_0_30, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckCount",1194,G__RAT_Dict_737_0_31, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFECDCount",1083,G__RAT_Dict_737_0_32, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpareCount",1316,G__RAT_Dict_737_0_33, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHQECount",1031,G__RAT_Dict_737_0_34, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInvalidCount",1520,G__RAT_Dict_737_0_35, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPMT",506,G__RAT_Dict_737_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RAT::DS::MCHit' - 11 - pmt i 'RAT::DU::PMTInfo::EPMTType' - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNormalPMT",1123,G__RAT_Dict_737_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOWLPMT",748,G__RAT_Dict_737_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLowGainPMT",1195,G__RAT_Dict_737_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBUTTPMT",825,G__RAT_Dict_737_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNeckPMT",891,G__RAT_Dict_737_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFECDPMT",780,G__RAT_Dict_737_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSparePMT",1013,G__RAT_Dict_737_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHQEPMT",728,G__RAT_Dict_737_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInvalidPMT",1217,G__RAT_Dict_737_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCHit' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneAllPMTs",1159,G__RAT_Dict_737_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNormalPMTs",1495,G__RAT_Dict_737_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInwardPMTs",1491,G__RAT_Dict_737_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneOWLPMTs",1120,G__RAT_Dict_737_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneLowGainPMTs",1567,G__RAT_Dict_737_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneBUTTPMTs",1197,G__RAT_Dict_737_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNeckPMTs",1263,G__RAT_Dict_737_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneFECDPMTs",1152,G__RAT_Dict_737_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneSparePMTs",1385,G__RAT_Dict_737_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneHQEPMTs",1100,G__RAT_Dict_737_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneInvalidPMTs",1589,G__RAT_Dict_737_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_737_0_57, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_737_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_737_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_737_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_737_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_737_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_737_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_737_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_737_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::PMTSet<RAT::DS::MCHit>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PMTSet<RAT::DS::MCHit>", 1714, G__RAT_Dict_737_0_69, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::MCHit>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTSet<RAT::DS::MCHit>", 1840, G__RAT_Dict_737_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_737_0_71, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::PMTSet<RAT::DS::MCHit>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLEV(void) {
   /* RAT::DS::EV */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV));
   G__memfunc_setup("EV",155,G__RAT_Dict_742_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUniversalTime",1652,G__RAT_Dict_742_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUniversalTime",1640,G__RAT_Dict_742_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUncalPMTs",1143,G__RAT_Dict_742_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR), G__defined_typename("RAT::DS::UncalPMTs"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUncalPMTs",1143,G__RAT_Dict_742_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR), G__defined_typename("RAT::DS::UncalPMTs"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalPMTs",916,G__RAT_Dict_742_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), G__defined_typename("RAT::DS::CalPMTs"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalPMTs",916,G__RAT_Dict_742_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), G__defined_typename("RAT::DS::CalPMTs"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMTCalType",1219,G__RAT_Dict_742_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCalPMTs",893,G__RAT_Dict_742_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RAT::DS::PMTSet<RAT::DS::PMTCal>' 'RAT::DS::CalPMTs' 11 - pmts h - 'UInt_t' 10 - calType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPartialCalPMTs",1633,G__RAT_Dict_742_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), G__defined_typename("RAT::DS::CalPMTs"), 1, 1, 1, 1, 0, "h - 'UInt_t' 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPartialCalPMTs",1633,G__RAT_Dict_742_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), G__defined_typename("RAT::DS::CalPMTs"), 1, 1, 1, 1, 9, "h - 'UInt_t' 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPartialPMTCalTypes",2051,G__RAT_Dict_742_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<UInt_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataCleaningFlags",1960,G__RAT_Dict_742_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataCleaningFlags",1960,G__RAT_Dict_742_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultFitVertex",1938,G__RAT_Dict_742_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 10 - name u 'RAT::DS::FitVertex' - 11 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefaultFitVertexExists",2278,G__RAT_Dict_742_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFitVertex",1926,G__RAT_Dict_742_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitVertex), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultFitName",1673,G__RAT_Dict_742_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneDefaultFit",1522,G__RAT_Dict_742_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFitterPass",1294,G__RAT_Dict_742_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitResults",1333,G__RAT_Dict_742_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR), G__defined_typename("RAT::DS::FitCollection"), 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitNames",1079,G__RAT_Dict_742_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitResult",1218,G__RAT_Dict_742_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FitResultExists",1570,G__RAT_Dict_742_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitResult",1230,G__RAT_Dict_742_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - pass u 'string' - 11 - name "
"u 'RAT::DS::FitResult' - 11 - fitResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneFitResults",1567,G__RAT_Dict_742_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClassifierPass",1701,G__RAT_Dict_742_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassifierResults",2071,G__RAT_Dict_742_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR), G__defined_typename("RAT::DS::ClassifierCollection"), 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassifierNames",1817,G__RAT_Dict_742_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassifierResult",1956,G__RAT_Dict_742_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClassifierResultExists",2308,G__RAT_Dict_742_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClassifierResult",1968,G__RAT_Dict_742_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - pass u 'string' - 11 - name "
"u 'RAT::DS::ClassifierResult' - 11 - classifierResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneClassifierResults",2305,G__RAT_Dict_742_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDigitiser",1232,G__RAT_Dict_742_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Digitiser' - 11 - dig", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDigitiser",1220,G__RAT_Dict_742_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDigitiser",1220,G__RAT_Dict_742_0_36, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitiserExists",1572,G__RAT_Dict_742_0_37, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneDigitiser",1454,G__RAT_Dict_742_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGTID",584,G__RAT_Dict_742_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGTID",596,G__RAT_Dict_742_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - gtid_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClockCount50",1402,G__RAT_Dict_742_0_41, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClockCount50",1414,G__RAT_Dict_742_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 10 - ticks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClockCount10",1398,G__RAT_Dict_742_0_43, 109, -1, G__defined_typename("ULong64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClockCount10",1410,G__RAT_Dict_742_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 10 - ticks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClockStat10",1289,G__RAT_Dict_742_0_45, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClockStat10",1301,G__RAT_Dict_742_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 10 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetESumPeak",1051,G__RAT_Dict_742_0_47, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetESumPeak",1063,G__RAT_Dict_742_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - eSumPeak_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetESumDerivative",1709,G__RAT_Dict_742_0_49, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetESumDerivative",1721,G__RAT_Dict_742_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - eSumDiff_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetESumIntegral",1488,G__RAT_Dict_742_0_51, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetESumIntegral",1500,G__RAT_Dict_742_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - eSumInt_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigError",1216,G__RAT_Dict_742_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigError",1228,G__RAT_Dict_742_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trigError_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigType",1112,G__RAT_Dict_742_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigType",1124,G__RAT_Dict_742_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - trigType_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTubiiTrig",1203,G__RAT_Dict_742_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTubiiTrigBit",1490,G__RAT_Dict_742_0_58, 103, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTubiiTrig",1215,G__RAT_Dict_742_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tubiiTrig_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTubiiTrigBit",1502,G__RAT_Dict_742_0_60, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - bit g - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TUBiiTrigExists",1491,G__RAT_Dict_742_0_61, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataSet",966,G__RAT_Dict_742_0_62, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSet",978,G__RAT_Dict_742_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dataSet_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalCharge",1390,G__RAT_Dict_742_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTotalCharge",1402,G__RAT_Dict_742_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - totalQ_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNhits",806,G__RAT_Dict_742_0_66, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNhits",818,G__RAT_Dict_742_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - nhits_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNhitsCleaned",1490,G__RAT_Dict_742_0_68, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNhitsCleaned",1502,G__RAT_Dict_742_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - nhits_cleaned_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInTimeHits100",1423,G__RAT_Dict_742_0_70, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInTimeHits100",1435,G__RAT_Dict_742_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - hits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInTimeHits20",1376,G__RAT_Dict_742_0_72, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInTimeHits20",1388,G__RAT_Dict_742_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - hits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalibrationEvent",1930,G__RAT_Dict_742_0_74, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCalibrationEvent",1942,G__RAT_Dict_742_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - iscal_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPollingEvent",1527,G__RAT_Dict_742_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPollingEvent",1539,G__RAT_Dict_742_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - ispolling_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_742_0_78, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::EV::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_742_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::EV::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_742_0_80, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::EV::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_742_0_81, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::EV::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_742_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_742_0_86, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::EV::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_742_0_87, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::EV::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_742_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::EV::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_742_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::EV::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("EV", 155, G__RAT_Dict_742_0_90, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::EV' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EV", 281, G__RAT_Dict_742_0_91, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_742_0_92, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::EV' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR(void) {
   /* map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR));
   G__memfunc_setup("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >",11969,G__RAT_Dict_745_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >",11969,G__RAT_Dict_745_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >",11969,G__RAT_Dict_745_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >",11969,G__RAT_Dict_745_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_745_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_745_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_745_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_745_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_745_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_745_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_745_0_11, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_745_0_12, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_745_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR), -1, 1, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_745_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >' 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_745_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - position u 'pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >' 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_745_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_745_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_745_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_745_0_19, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::size_type"), 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_745_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_745_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_745_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_745_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_745_0_24, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::size_type"), 0, 1, 1, 1, 8, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_745_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_745_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >", 12095, G__RAT_Dict_745_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR(void) {
   /* pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR));
   G__memfunc_setup("pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >",4254,G__RAT_Dict_746_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >",4254,G__RAT_Dict_746_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - - 11 - a u 'RAT::DS::PMTSet<RAT::DS::PMTCal>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR), -1, 1, 1, 1, 4, 0, "u 'pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >", 4254, G__RAT_Dict_746_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >", 4380, G__RAT_Dict_746_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR(void) {
   /* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR));
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >",16433,G__RAT_Dict_752_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >",16433,G__RAT_Dict_752_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >",16433,G__RAT_Dict_752_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >",16433,G__RAT_Dict_752_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_752_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_752_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_752_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_752_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_752_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_752_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_752_0_11, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_752_0_12, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_752_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR), -1, 1, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_752_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >' 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_752_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - position u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >' 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_752_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_752_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_752_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_752_0_19, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::size_type"), 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_752_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_752_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_752_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_752_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_752_0_24, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::size_type"), 0, 1, 1, 1, 8, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_752_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_752_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >", 16559, G__RAT_Dict_752_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR(void) {
   /* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR));
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >",6486,G__RAT_Dict_753_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >",6486,G__RAT_Dict_753_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - - 11 - a u 'RAT::DS::FitClassifierCollection<RAT::DS::FitResult>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR), -1, 1, 1, 1, 4, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >", 6486, G__RAT_Dict_753_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >", 6612, G__RAT_Dict_753_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR(void) {
   /* map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR));
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >",17909,G__RAT_Dict_759_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >",17909,G__RAT_Dict_759_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >",17909,G__RAT_Dict_759_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >",17909,G__RAT_Dict_759_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_759_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_759_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_759_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_759_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_759_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_759_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_759_0_11, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_759_0_12, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_759_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR), -1, 1, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_759_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >' 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_759_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - position u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >' 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_759_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_759_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_759_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_759_0_19, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::size_type"), 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_759_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_759_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_759_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_759_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_759_0_24, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::size_type"), 0, 1, 1, 1, 8, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_759_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_759_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >", 18035, G__RAT_Dict_759_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR(void) {
   /* pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR));
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >",7224,G__RAT_Dict_760_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >",7224,G__RAT_Dict_760_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - - 11 - a u 'RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR), -1, 1, 1, 1, 4, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >", 7224, G__RAT_Dict_760_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >", 7350, G__RAT_Dict_760_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLTrigHeader(void) {
   /* RAT::DS::TrigHeader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader));
   G__memfunc_setup("TrigHeader",991,G__RAT_Dict_768_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigMask",1102,G__RAT_Dict_768_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigMask",1090,G__RAT_Dict_768_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPulserRate",1331,G__RAT_Dict_768_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - rate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPulserRate",1319,G__RAT_Dict_768_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMTC_CSR",855,G__RAT_Dict_768_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - contents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMTC_CSR",843,G__RAT_Dict_768_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLockoutWidth",1549,G__RAT_Dict_768_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLockoutWidth",1537,G__RAT_Dict_768_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrescaleFrequency",2061,G__RAT_Dict_768_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - frequency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrescaleFrequency",2049,G__RAT_Dict_768_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTriggerThreshold",1965,G__RAT_Dict_768_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"r - 'UShort_t' 10 - bit r - 'UShort_t' 10 - threshold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTriggerThreshold",1953,G__RAT_Dict_768_0_13, 114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 8, "r - 'UShort_t' 10 - bit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigZeroOffset",1737,G__RAT_Dict_768_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"r - 'UShort_t' 10 - bit r - 'UShort_t' 10 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTriggerZeroOffset",2043,G__RAT_Dict_768_0_15, 114, -1, G__defined_typename("UShort_t"), 0, 1, 1, 1, 8, "r - 'UShort_t' 10 - bit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_768_0_16, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::TrigHeader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_768_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::TrigHeader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_768_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::TrigHeader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_768_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::TrigHeader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_768_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_768_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::TrigHeader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_768_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::TrigHeader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_768_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::TrigHeader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_768_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::TrigHeader::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TrigHeader", 991, G__RAT_Dict_768_0_28, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::TrigHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrigHeader", 1117, G__RAT_Dict_768_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_768_0_30, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::TrigHeader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLHeaderInfo(void) {
   /* RAT::DS::HeaderInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo));
   G__memfunc_setup("HeaderInfo",981,G__RAT_Dict_777_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetECAHeader",1086,G__RAT_Dict_777_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::ECAHeader' - 11 - header", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ECAHeaderExists",1426,G__RAT_Dict_777_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetECAHeader",1074,G__RAT_Dict_777_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetECAHeader",1074,G__RAT_Dict_777_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneECAHeader",1308,G__RAT_Dict_777_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrigHeader",1291,G__RAT_Dict_777_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::TrigHeader' - 11 - header", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrigHeaderExists",1631,G__RAT_Dict_777_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigHeader",1279,G__RAT_Dict_777_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigrHeader",1393,G__RAT_Dict_777_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneTrigHeader",1513,G__RAT_Dict_777_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_777_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::HeaderInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_777_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::HeaderInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_777_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::HeaderInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_777_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::HeaderInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_777_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_777_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::HeaderInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_777_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::HeaderInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_777_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::HeaderInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_777_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::HeaderInfo::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HeaderInfo", 981, G__RAT_Dict_777_0_24, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::HeaderInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HeaderInfo", 1107, G__RAT_Dict_777_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_777_0_26, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::HeaderInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR(void) {
   /* vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_779_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_779_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_779_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_779_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_779_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_779_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_779_0_7, 107, -1, G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_779_0_8, 107, -1, G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_779_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_779_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - sz u 'RAT::DS::ECAHeader' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_779_0_11, 107, -1, G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_779_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_779_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_779_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), G__defined_typename("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >",4740,G__RAT_Dict_779_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >",4740,G__RAT_Dict_779_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n u 'RAT::DS::ECAHeader' - 11 'RAT::DS::ECAHeader()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >",4740,G__RAT_Dict_779_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >",4740,G__RAT_Dict_779_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator' 10 - first u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_779_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_779_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_779_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_779_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_779_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::ECAHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_779_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_779_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - position u 'RAT::DS::ECAHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_779_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - position u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_779_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - position k - 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::size_type' 0 - n "
"u 'RAT::DS::ECAHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_779_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_779_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_779_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - first u 'vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_779_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >", 4866, G__RAT_Dict_779_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR(void) {
   /* vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_783_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_783_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_783_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_783_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_783_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_783_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_783_0_7, 107, -1, G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_783_0_8, 107, -1, G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_783_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_783_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - sz u 'RAT::DS::TrigHeader' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_783_0_11, 107, -1, G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_783_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_783_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_783_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), G__defined_typename("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >",5150,G__RAT_Dict_783_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >",5150,G__RAT_Dict_783_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n u 'RAT::DS::TrigHeader' - 11 'RAT::DS::TrigHeader()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >",5150,G__RAT_Dict_783_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >",5150,G__RAT_Dict_783_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator' 10 - first u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_783_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_783_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_783_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_783_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_783_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::TrigHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_783_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_783_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - position u 'RAT::DS::TrigHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_783_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - position u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_783_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - position k - 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::size_type' 0 - n "
"u 'RAT::DS::TrigHeader' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_783_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_783_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_783_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - first u 'vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_783_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >", 5276, G__RAT_Dict_783_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMetaDB(void) {
   /* RAT::DS::MetaDB */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB));
   G__memfunc_setup("MetaDB",525,G__RAT_Dict_786_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOverrideCommand",1800,G__RAT_Dict_786_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - tableField u 'string' - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFile",649,G__RAT_Dict_786_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverrideCommand",1823,G__RAT_Dict_786_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR), G__defined_typename("pair<std::string,std::string>"), 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverrideCommandCount",2344,G__RAT_Dict_786_0_5, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFile",672,G__RAT_Dict_786_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFileCount",1193,G__RAT_Dict_786_0_7, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_786_0_8, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MetaDB::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_786_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MetaDB::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_786_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MetaDB::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_786_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MetaDB::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_786_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_786_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MetaDB::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_786_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MetaDB::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_786_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MetaDB::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_786_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MetaDB::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MetaDB", 525, G__RAT_Dict_786_0_20, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MetaDB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MetaDB", 651, G__RAT_Dict_786_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_786_0_22, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MetaDB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEstringcOstringgR(void) {
   /* pair<string,string> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR));
   G__memfunc_setup("pair<string,string>",1920,G__RAT_Dict_787_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<string,string>",1920,G__RAT_Dict_787_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - a u 'string' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR), -1, 1, 1, 1, 4, 0, "u 'pair<string,string>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<string,string>", 1920, G__RAT_Dict_787_0_4, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_pairlEstringcOstringgR), -1, 0, 1, 1, 1, 0, "u 'pair<string,string>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<string,string>", 2046, G__RAT_Dict_787_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLRun(void) {
   /* RAT::DS::Run */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun));
   G__memfunc_setup("Run",309,G__RAT_Dict_792_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRunID",750,G__RAT_Dict_792_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunID",738,G__RAT_Dict_792_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubRunID",1048,G__RAT_Dict_792_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubRunID",1036,G__RAT_Dict_792_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDate",682,G__RAT_Dict_792_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - date_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDate",670,G__RAT_Dict_792_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_792_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_792_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRunType",1027,G__RAT_Dict_792_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunType",1015,G__RAT_Dict_792_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFirstGTID",1116,G__RAT_Dict_792_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - gtid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstGTID",1104,G__RAT_Dict_792_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValidGTID",1092,G__RAT_Dict_792_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - gtid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidGTID",1080,G__RAT_Dict_792_0_15, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBuilderVersion",1753,G__RAT_Dict_792_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuilderVersion",1741,G__RAT_Dict_792_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataQualityFlags",1904,G__RAT_Dict_792_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataQualityFlags",1904,G__RAT_Dict_792_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNMCEvents",1784,G__RAT_Dict_792_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNMCEvents",1139,G__RAT_Dict_792_0_21, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMCFlag",822,G__RAT_Dict_792_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunLength",1207,G__RAT_Dict_792_0_23, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRunLength",1219,G__RAT_Dict_792_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - _runLength", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMCFlag",810,G__RAT_Dict_792_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDigitiserTrigSums",2062,G__RAT_Dict_792_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<Int_t>' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDigitiserTrigSum",1947,G__RAT_Dict_792_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 10 - id i - 'Int_t' 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDigitiserTrigSums",2050,G__RAT_Dict_792_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDigitiserTrigSum",1935,G__RAT_Dict_792_0_29, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneDigitiserTrigSums",2284,G__RAT_Dict_792_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SOCDataExists",1247,G__RAT_Dict_792_0_31, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSOCData",907,G__RAT_Dict_792_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - id u 'RAT::DS::SOC' - 11 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCData",895,G__RAT_Dict_792_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCData",895,G__RAT_Dict_792_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCSourceIDs",1398,G__RAT_Dict_792_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSSBitsExist",1160,G__RAT_Dict_792_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCSSBits",935,G__RAT_Dict_792_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 10 - lcn u 'RAT::DS::BitMask' - 11 - cssBit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCSSBits",923,G__RAT_Dict_792_0_38, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCSSBits",923,G__RAT_Dict_792_0_39, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_792_0_40, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::Run::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_792_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Run::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_792_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::Run::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_792_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::Run::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_792_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_792_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Run::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_792_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Run::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_792_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Run::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_792_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Run::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Run", 309, G__RAT_Dict_792_0_52, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Run' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Run", 435, G__RAT_Dict_792_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_792_0_54, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::Run' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMeta(void) {
   /* RAT::DS::Meta */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta));
   G__memfunc_setup("Meta",391,G__RAT_Dict_793_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewPass",705,G__RAT_Dict_793_0_2, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'string' - 11 - name u 'string' - 11 - system "
"u 'string' - 11 - version u 'string' - 11 - revision "
"u 'string' - 11 - geant4Version u 'string' - 11 - rootVersion", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompletePass",1232,G__RAT_Dict_793_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::MetaHelper' - 11 - helper", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentPass",1434,G__RAT_Dict_793_0_4, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPassCount",1216,G__RAT_Dict_793_0_5, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMetaDB",813,G__RAT_Dict_793_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMetaDB",813,G__RAT_Dict_793_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMetaDBs",928,G__RAT_Dict_793_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), G__defined_typename("vector<RAT::DS::MetaDB>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHostNames",1202,G__RAT_Dict_793_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHostSystems",1462,G__RAT_Dict_793_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVersions",1145,G__RAT_Dict_793_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRevisions",1250,G__RAT_Dict_793_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeant4Versions",1692,G__RAT_Dict_793_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRootVersions",1565,G__RAT_Dict_793_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainsMCFlags",1756,G__RAT_Dict_793_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContainsDataFlags",1990,G__RAT_Dict_793_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventsGeneratedCounts",2464,G__RAT_Dict_793_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventsStoredCounts",2178,G__RAT_Dict_793_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_793_0_19, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::Meta::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_793_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Meta::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_793_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::Meta::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_793_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::Meta::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_793_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_793_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Meta::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_793_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Meta::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_793_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Meta::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_793_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Meta::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Meta", 391, G__RAT_Dict_793_0_31, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Meta' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Meta", 517, G__RAT_Dict_793_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_793_0_33, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::Meta' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR(void) {
   /* vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_796_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_796_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_796_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_796_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_796_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_796_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_796_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_796_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_796_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_796_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - sz u 'RAT::DS::MetaDB' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_796_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_796_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_796_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_796_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), G__defined_typename("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >",4218,G__RAT_Dict_796_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >",4218,G__RAT_Dict_796_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n u 'RAT::DS::MetaDB' - 11 'RAT::DS::MetaDB()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >",4218,G__RAT_Dict_796_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >",4218,G__RAT_Dict_796_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator' 10 - first u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_796_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_796_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_796_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_796_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMetaDB), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_796_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MetaDB' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_796_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_796_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - position u 'RAT::DS::MetaDB' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_796_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - position u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_796_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - position k - 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::size_type' 0 - n "
"u 'RAT::DS::MetaDB' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_796_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_796_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_796_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - first u 'vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_796_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >", 4344, G__RAT_Dict_796_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCParticle(void) {
   /* RAT::DS::MCParticle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle));
   G__memfunc_setup("MCParticle",964,G__RAT_Dict_799_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__RAT_Dict_799_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_799_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPolarisation",1569,G__RAT_Dict_799_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarisation",1557,G__RAT_Dict_799_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__RAT_Dict_799_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - mom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__RAT_Dict_799_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPDGCode",898,G__RAT_Dict_799_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDGCode",886,G__RAT_Dict_799_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTime",699,G__RAT_Dict_799_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_799_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKineticEnergy",1629,G__RAT_Dict_799_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKineticEnergy",1617,G__RAT_Dict_799_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertexID",1079,G__RAT_Dict_799_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertexID",1067,G__RAT_Dict_799_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMetaInfo",1087,G__RAT_Dict_799_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 10 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMetaInfo",1075,G__RAT_Dict_799_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_799_0_18, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCParticle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_799_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCParticle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_799_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCParticle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_799_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCParticle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_799_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_799_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCParticle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_799_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCParticle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_799_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCParticle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_799_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCParticle::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCParticle", 964, G__RAT_Dict_799_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCParticle", 1090, G__RAT_Dict_799_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_799_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCTrackStep(void) {
   /* RAT::DS::MCTrackStep */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep));
   G__memfunc_setup("MCTrackStep",1057,G__RAT_Dict_800_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__RAT_Dict_800_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_800_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPolarisation",1569,G__RAT_Dict_800_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolarisation",1557,G__RAT_Dict_800_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__RAT_Dict_800_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - mom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__RAT_Dict_800_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStartVolume",1458,G__RAT_Dict_800_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStartVolume",1446,G__RAT_Dict_800_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEndVolume",1211,G__RAT_Dict_800_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndVolume",1199,G__RAT_Dict_800_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLength",910,G__RAT_Dict_800_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - len", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLength",898,G__RAT_Dict_800_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalTime",1292,G__RAT_Dict_800_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalTime",1280,G__RAT_Dict_800_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalTime",1190,G__RAT_Dict_800_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalTime",1178,G__RAT_Dict_800_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProperTime",1331,G__RAT_Dict_800_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProperTime",1319,G__RAT_Dict_800_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKineticEnergy",1629,G__RAT_Dict_800_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKineticEnergy",1617,G__RAT_Dict_800_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDepositedEnergy",1847,G__RAT_Dict_800_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepositedEnergy",1835,G__RAT_Dict_800_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatus",944,G__RAT_Dict_800_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RAT::DS::MCTrackStep::EStatus' - 10 - status_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__RAT_Dict_800_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProcess",1035,G__RAT_Dict_800_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProcess",1023,G__RAT_Dict_800_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProcessEnum",1428,G__RAT_Dict_800_0_28, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_800_0_29, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCTrackStep::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_800_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrackStep::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_800_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCTrackStep::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_800_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCTrackStep::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_800_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_800_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrackStep::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_800_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCTrackStep::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_800_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrackStep::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_800_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCTrackStep::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCTrackStep", 1057, G__RAT_Dict_800_0_41, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrackStep' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCTrackStep", 1183, G__RAT_Dict_800_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_800_0_43, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCTrackStep' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCTrack(void) {
   /* RAT::DS::MCTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack));
   G__memfunc_setup("MCTrack",645,G__RAT_Dict_803_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrackID",942,G__RAT_Dict_803_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackID",930,G__RAT_Dict_803_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParentID",1059,G__RAT_Dict_803_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentID",1047,G__RAT_Dict_803_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPDGCode",898,G__RAT_Dict_803_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDGCode",886,G__RAT_Dict_803_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParticleName",1505,G__RAT_Dict_803_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParticleName",1493,G__RAT_Dict_803_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLength",910,G__RAT_Dict_803_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - totalLength", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLength",898,G__RAT_Dict_803_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDepositedEnergy",1847,G__RAT_Dict_803_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - totalDepositedEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepositedEnergy",1835,G__RAT_Dict_803_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__RAT_Dict_803_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - weight_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__RAT_Dict_803_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSummaryFlag",1428,G__RAT_Dict_803_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'RAT::DS::MCTrack::ESummaryFlag' - 10 - flag g - 'Bool_t' 0 'true' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSummaryFlag",1416,G__RAT_Dict_803_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i 'RAT::DS::MCTrack::ESummaryFlag' - 10 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCTrackStep",1322,G__RAT_Dict_803_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrackStep' - 11 - trackStep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackStepCount",1866,G__RAT_Dict_803_0_19, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstMCTrackStep",1865,G__RAT_Dict_803_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackStep",1345,G__RAT_Dict_803_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackStep",1345,G__RAT_Dict_803_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastMCTrackStep",1749,G__RAT_Dict_803_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCTrackSteps",1694,G__RAT_Dict_803_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCTrackStepsByIndex",2385,G__RAT_Dict_803_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<unsigned long,less<unsigned long>,allocator<unsigned long> >' 'set<size_t>' 11 - indices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneIntermediateMCTrackSteps",2937,G__RAT_Dict_803_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_803_0_27, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_803_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_803_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_803_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_803_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_803_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_803_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_803_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_803_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCTrack", 645, G__RAT_Dict_803_0_39, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCTrack", 771, G__RAT_Dict_803_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_803_0_41, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR(void) {
   /* vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_812_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_812_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_812_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_812_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_812_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_812_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_812_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_812_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_812_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_812_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - sz u 'RAT::DS::MCTrackStep' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_812_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_812_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_812_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_812_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), G__defined_typename("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >",5282,G__RAT_Dict_812_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >",5282,G__RAT_Dict_812_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n u 'RAT::DS::MCTrackStep' - 11 'RAT::DS::MCTrackStep()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >",5282,G__RAT_Dict_812_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >",5282,G__RAT_Dict_812_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator' 10 - first u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_812_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_812_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_812_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_812_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_812_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrackStep' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_812_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_812_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - position u 'RAT::DS::MCTrackStep' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_812_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - position u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_812_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - position k - 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::size_type' 0 - n "
"u 'RAT::DS::MCTrackStep' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_812_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_812_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_812_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - first u 'vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_812_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >", 5408, G__RAT_Dict_812_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCPhoton(void) {
   /* RAT::DS::MCPhoton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton));
   G__memfunc_setup("MCPhoton",776,G__RAT_Dict_815_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInPosition",1336,G__RAT_Dict_815_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInPosition",1324,G__RAT_Dict_815_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInDirection",1412,G__RAT_Dict_815_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInDirection",1400,G__RAT_Dict_815_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInPolarisation",1752,G__RAT_Dict_815_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInPolarisation",1740,G__RAT_Dict_815_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInTime",882,G__RAT_Dict_815_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInTime",870,G__RAT_Dict_815_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutPosition",1465,G__RAT_Dict_815_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutPosition",1453,G__RAT_Dict_815_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutDirection",1541,G__RAT_Dict_815_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutDirection",1529,G__RAT_Dict_815_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutPolarisation",1881,G__RAT_Dict_815_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutPolarisation",1869,G__RAT_Dict_815_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutTime",1011,G__RAT_Dict_815_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutTime",999,G__RAT_Dict_815_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergy",918,G__RAT_Dict_815_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergy",906,G__RAT_Dict_815_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__RAT_Dict_815_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - weight_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__RAT_Dict_815_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhotonTrackID",1574,G__RAT_Dict_815_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhotonTrackID",1562,G__RAT_Dict_815_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPMTID",682,G__RAT_Dict_815_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMTID",670,G__RAT_Dict_815_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFate",684,G__RAT_Dict_815_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RAT::DS::MCPhoton::EPhotonFate' - 0 - fate_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFate",672,G__RAT_Dict_815_0_27, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_815_0_28, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCPhoton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_815_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPhoton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_815_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCPhoton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_815_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCPhoton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_815_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_815_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPhoton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_815_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPhoton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_815_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPhoton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_815_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPhoton::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCPhoton", 776, G__RAT_Dict_815_0_40, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPhoton' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCPhoton", 902, G__RAT_Dict_815_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_815_0_42, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCPhoton' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCPE(void) {
   /* RAT::DS::MCPE */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE));
   G__memfunc_setup("MCPE",293,G__RAT_Dict_818_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__RAT_Dict_818_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_818_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCreationTime",1520,G__RAT_Dict_818_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCreationTime",1508,G__RAT_Dict_818_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrontEndTime",1499,G__RAT_Dict_818_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrontEndTime",1487,G__RAT_Dict_818_0_7, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCharge",886,G__RAT_Dict_818_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 10 - charge_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCharge",874,G__RAT_Dict_818_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhotonTrackID",1574,G__RAT_Dict_818_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhotonTrackID",1562,G__RAT_Dict_818_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNoise",810,G__RAT_Dict_818_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 'true' noise_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoise",798,G__RAT_Dict_818_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistory",1042,G__RAT_Dict_818_0_14, 114, -1, G__defined_typename("UShort_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToHistory",1214,G__RAT_Dict_818_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'RAT::DS::MCPE::PhotonHistory' - 0 - bit i 'RAT::DS::MCPE::PhHistoryStatus' - 0 'hSet' status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistory",1054,G__RAT_Dict_818_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - word", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFromHistory",1446,G__RAT_Dict_818_0_17, 103, -1, -1, 0, 1, 1, 1, 8, "i 'RAT::DS::MCPE::PhotonHistory' - 0 - bit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAfterPulse",1319,G__RAT_Dict_818_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 'true' afterpulse_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAfterPulse",1307,G__RAT_Dict_818_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_818_0_20, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCPE::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_818_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPE::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_818_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCPE::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_818_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCPE::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_818_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_818_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPE::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_818_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPE::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_818_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPE::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_818_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPE::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCPE", 293, G__RAT_Dict_818_0_32, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPE' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCPE", 419, G__RAT_Dict_818_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_818_0_34, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCPE' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCPMT(void) {
   /* RAT::DS::MCPMT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT));
   G__memfunc_setup("MCPMT",385,G__RAT_Dict_822_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCPMT",385,G__RAT_Dict_822_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__RAT_Dict_822_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetID",441,G__RAT_Dict_822_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - pmtID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPhoton",1064,G__RAT_Dict_822_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPhoton",1064,G__RAT_Dict_822_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPhotonCount",1585,G__RAT_Dict_822_0_7, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCPhoton",1041,G__RAT_Dict_822_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPhoton' - 11 - photon", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCPhotons",1413,G__RAT_Dict_822_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPE",581,G__RAT_Dict_822_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPE",581,G__RAT_Dict_822_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPECount",1102,G__RAT_Dict_822_0_12, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCPE",558,G__RAT_Dict_822_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPE' - 11 - photoelectron", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCPEs",930,G__RAT_Dict_822_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortMCPEs",832,G__RAT_Dict_822_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_822_0_16, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCPMT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_822_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPMT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_822_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCPMT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_822_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCPMT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_822_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_822_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPMT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_822_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPMT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_822_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCPMT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_822_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCPMT::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCPMT", 385, G__RAT_Dict_822_0_28, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCPMT", 511, G__RAT_Dict_822_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_822_0_30, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR(void) {
   /* vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_824_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_824_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_824_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_824_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_824_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_824_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_824_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_824_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_824_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_824_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - sz u 'RAT::DS::MCPhoton' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_824_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_824_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_824_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_824_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), G__defined_typename("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >",4720,G__RAT_Dict_824_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >",4720,G__RAT_Dict_824_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n u 'RAT::DS::MCPhoton' - 11 'RAT::DS::MCPhoton()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >",4720,G__RAT_Dict_824_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >",4720,G__RAT_Dict_824_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator' 10 - first u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_824_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_824_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_824_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_824_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_824_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPhoton' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_824_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_824_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - position u 'RAT::DS::MCPhoton' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_824_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - position u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_824_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - position k - 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::size_type' 0 - n "
"u 'RAT::DS::MCPhoton' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_824_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_824_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_824_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - first u 'vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_824_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >", 4846, G__RAT_Dict_824_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR(void) {
   /* vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_828_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_828_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_828_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_828_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_828_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_828_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_828_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_828_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_828_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_828_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - sz u 'RAT::DS::MCPE' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_828_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_828_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_828_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_828_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), G__defined_typename("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >",3754,G__RAT_Dict_828_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >",3754,G__RAT_Dict_828_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n u 'RAT::DS::MCPE' - 11 'RAT::DS::MCPE()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >",3754,G__RAT_Dict_828_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >",3754,G__RAT_Dict_828_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator' 10 - first u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_828_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_828_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_828_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_828_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPE), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_828_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPE' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_828_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_828_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - position u 'RAT::DS::MCPE' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_828_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - position u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_828_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - position k - 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::size_type' 0 - n "
"u 'RAT::DS::MCPE' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_828_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_828_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_828_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - first u 'vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_828_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >", 3880, G__RAT_Dict_828_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMC(void) {
   /* RAT::DS::MC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC));
   G__memfunc_setup("MC",144,G__RAT_Dict_831_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMCID",585,G__RAT_Dict_831_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - eventID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCID",573,G__RAT_Dict_831_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMCTime",843,G__RAT_Dict_831_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTime",831,G__RAT_Dict_831_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUniversalTime",1652,G__RAT_Dict_831_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::UniversalTime' - 11 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUniversalTime",1640,G__RAT_Dict_831_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCParent",1027,G__RAT_Dict_831_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCParticle' - 11 - particle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParentCount",1571,G__RAT_Dict_831_0_9, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParent",1050,G__RAT_Dict_831_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParent",1050,G__RAT_Dict_831_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCParents",1399,G__RAT_Dict_831_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCParticle",1229,G__RAT_Dict_831_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCParticle' - 11 - particle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParticleCount",1773,G__RAT_Dict_831_0_14, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParticle",1252,G__RAT_Dict_831_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCParticle",1252,G__RAT_Dict_831_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCParticles",1601,G__RAT_Dict_831_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCTrack",910,G__RAT_Dict_831_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrack' - 11 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackCount",1454,G__RAT_Dict_831_0_19, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackIDs",1189,G__RAT_Dict_831_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrack",933,G__RAT_Dict_831_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - trackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrack",933,G__RAT_Dict_831_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - trackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackFromIndex",1841,G__RAT_Dict_831_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCTrackID",1074,G__RAT_Dict_831_0_24, 107, -1, G__defined_typename("size_t"), 0, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCTracks",1282,G__RAT_Dict_831_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCTracksByIndex",1973,G__RAT_Dict_831_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<unsigned long,less<unsigned long>,allocator<unsigned long> >' 'set<size_t>' 11 - indices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCPMT",650,G__RAT_Dict_831_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPMT' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPMTCount",1194,G__RAT_Dict_831_0_28, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPMT",673,G__RAT_Dict_831_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPMT",673,G__RAT_Dict_831_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCPMTs",1022,G__RAT_Dict_831_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnbuiltMCHits",1579,G__RAT_Dict_831_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), G__defined_typename("RAT::DS::MCHits"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnbuiltMCHits",1579,G__RAT_Dict_831_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), G__defined_typename("RAT::DS::MCHits"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMCPECount",1114,G__RAT_Dict_831_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - photoelectrons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCPECount",1102,G__RAT_Dict_831_0_35, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumDirPE",1040,G__RAT_Dict_831_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - _numDirPE", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumDirPE",1028,G__RAT_Dict_831_0_37, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNCherPhotons",1511,G__RAT_Dict_831_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - cerenkovPhotons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCherPhotons",1499,G__RAT_Dict_831_0_39, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNScintPhotons",1638,G__RAT_Dict_831_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - scintillatedPhotons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNScintPhotons",1626,G__RAT_Dict_831_0_41, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNReemittedPhotons",2056,G__RAT_Dict_831_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - reemittedPhotons", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNReemittedPhotons",2044,G__RAT_Dict_831_0_43, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialScintTime",1926,G__RAT_Dict_831_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - initialTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitialScintTime",1914,G__RAT_Dict_831_0_45, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScintEnergyDeposit",2159,G__RAT_Dict_831_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScintEnergyDeposit",2147,G__RAT_Dict_831_0_47, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScintQuenchedEnergyDeposit",2972,G__RAT_Dict_831_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScintQuenchedEnergyDeposit",2960,G__RAT_Dict_831_0_49, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_831_0_50, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MC::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_831_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MC::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_831_0_52, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MC::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_831_0_53, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MC::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_831_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_831_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MC::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_831_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MC::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_831_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MC::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_831_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MC::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MC", 144, G__RAT_Dict_831_0_62, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MC' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MC", 270, G__RAT_Dict_831_0_63, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_831_0_64, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MC' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR(void) {
   /* vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_833_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_833_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_833_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_833_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_833_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_833_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_833_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_833_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_833_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_833_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - sz u 'RAT::DS::MCParticle' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_833_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_833_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_833_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_833_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), G__defined_typename("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >",5096,G__RAT_Dict_833_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >",5096,G__RAT_Dict_833_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n u 'RAT::DS::MCParticle' - 11 'RAT::DS::MCParticle()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >",5096,G__RAT_Dict_833_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >",5096,G__RAT_Dict_833_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator' 10 - first u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_833_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_833_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_833_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_833_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCParticle), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_833_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCParticle' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_833_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_833_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - position u 'RAT::DS::MCParticle' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_833_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - position u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_833_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - position k - 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::size_type' 0 - n "
"u 'RAT::DS::MCParticle' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_833_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_833_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_833_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - first u 'vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_833_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >", 5222, G__RAT_Dict_833_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR(void) {
   /* vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_837_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_837_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_837_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_837_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_837_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_837_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_837_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_837_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_837_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_837_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - sz u 'RAT::DS::MCTrack' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_837_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_837_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_837_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_837_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), G__defined_typename("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >",4458,G__RAT_Dict_837_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >",4458,G__RAT_Dict_837_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n u 'RAT::DS::MCTrack' - 11 'RAT::DS::MCTrack()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >",4458,G__RAT_Dict_837_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >",4458,G__RAT_Dict_837_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator' 10 - first u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_837_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_837_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_837_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_837_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCTrack), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_837_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCTrack' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_837_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_837_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - position u 'RAT::DS::MCTrack' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_837_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - position u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_837_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - position k - 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::size_type' 0 - n "
"u 'RAT::DS::MCTrack' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_837_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_837_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_837_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - first u 'vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_837_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >", 4584, G__RAT_Dict_837_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR(void) {
   /* vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_841_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_841_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_841_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_841_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_841_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_841_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_841_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_841_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_841_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_841_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - sz u 'RAT::DS::MCPMT' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_841_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_841_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_841_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_841_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), G__defined_typename("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >",3938,G__RAT_Dict_841_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >",3938,G__RAT_Dict_841_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n u 'RAT::DS::MCPMT' - 11 'RAT::DS::MCPMT()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >",3938,G__RAT_Dict_841_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >",3938,G__RAT_Dict_841_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator' 10 - first u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_841_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_841_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_841_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_841_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCPMT), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_841_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCPMT' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_841_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_841_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - position u 'RAT::DS::MCPMT' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_841_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - position u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_841_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - position k - 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::size_type' 0 - n "
"u 'RAT::DS::MCPMT' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_841_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_841_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_841_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - first u 'vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_841_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >", 4064, G__RAT_Dict_841_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLMCEV(void) {
   /* RAT::DS::MCEV */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV));
   G__memfunc_setup("MCEV",299,G__RAT_Dict_844_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCHits",840,G__RAT_Dict_844_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), G__defined_typename("RAT::DS::MCHits"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCHits",840,G__RAT_Dict_844_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), G__defined_typename("RAT::DS::MCHits"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGTID",596,G__RAT_Dict_844_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGTID",584,G__RAT_Dict_844_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFullTrigType",1515,G__RAT_Dict_844_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFullTrigType",1527,G__RAT_Dict_844_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - fullTrigType_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGTTime",854,G__RAT_Dict_844_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - gt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGTTime",842,G__RAT_Dict_844_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_844_0_10, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::MCEV::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_844_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCEV::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_844_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::MCEV::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_844_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::MCEV::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_844_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_844_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCEV::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_844_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCEV::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_844_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::MCEV::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_844_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::MCEV::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCEV", 299, G__RAT_Dict_844_0_22, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCEV' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCEV", 425, G__RAT_Dict_844_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_844_0_24, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCEV' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLEntry(void) {
   /* RAT::DS::Entry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry));
   G__memfunc_setup("Entry",530,G__RAT_Dict_845_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRunID",750,G__RAT_Dict_845_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunID",738,G__RAT_Dict_845_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubRunID",1048,G__RAT_Dict_845_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubRunID",1036,G__RAT_Dict_845_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSeed",685,G__RAT_Dict_845_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 10 - seed_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeed",673,G__RAT_Dict_845_0_7, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMC",444,G__RAT_Dict_845_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MC' - 11 - mc_", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCExists",784,G__RAT_Dict_845_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMC",432,G__RAT_Dict_845_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMC",432,G__RAT_Dict_845_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMC",666,G__RAT_Dict_845_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllMCHits",1121,G__RAT_Dict_845_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR), G__defined_typename("RAT::DS::MCHits"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMCEV",564,G__RAT_Dict_845_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCEV' - 11 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCEVCount",1108,G__RAT_Dict_845_0_15, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCEV",587,G__RAT_Dict_845_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMCEV",587,G__RAT_Dict_845_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneMCEVs",936,G__RAT_Dict_845_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEV",420,G__RAT_Dict_845_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::EV' - 11 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEVCount",964,G__RAT_Dict_845_0_20, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEV",443,G__RAT_Dict_845_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 1, 1, 1, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEV",443,G__RAT_Dict_845_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 1, 1, 1, 1, 9, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneEVs",792,G__RAT_Dict_845_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHeaderInfo",1281,G__RAT_Dict_845_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::HeaderInfo' - 1 - header", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HeaderInfoExists",1621,G__RAT_Dict_845_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeaderInfo",1269,G__RAT_Dict_845_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeaderInfo",1269,G__RAT_Dict_845_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneHeaderInfos",1618,G__RAT_Dict_845_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalib",763,G__RAT_Dict_845_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalib",763,G__RAT_Dict_845_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_845_0_31, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::Entry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_845_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Entry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_845_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::Entry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_845_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::Entry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_845_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_845_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Entry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_845_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Entry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_845_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::Entry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_845_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::Entry::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Entry", 530, G__RAT_Dict_845_0_43, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Entry' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Entry", 656, G__RAT_Dict_845_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_845_0_45, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::Entry' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR(void) {
   /* vector<RAT::DS::MC,allocator<RAT::DS::MC> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_847_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_847_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_847_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_847_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_847_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_847_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_847_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_847_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_847_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_847_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - sz u 'RAT::DS::MC' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_847_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_847_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_847_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_847_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), G__defined_typename("vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MC,allocator<RAT::DS::MC> >",3456,G__RAT_Dict_847_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MC,allocator<RAT::DS::MC> >",3456,G__RAT_Dict_847_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n u 'RAT::DS::MC' - 11 'RAT::DS::MC()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MC,allocator<RAT::DS::MC> >",3456,G__RAT_Dict_847_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MC,allocator<RAT::DS::MC> >",3456,G__RAT_Dict_847_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator' 10 - first u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_847_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_847_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_847_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_847_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMC), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_847_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MC' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_847_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_847_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - position u 'RAT::DS::MC' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_847_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - position u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_847_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - position k - 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::size_type' 0 - n "
"u 'RAT::DS::MC' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_847_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_847_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_847_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - first u 'vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_847_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MC,allocator<RAT::DS::MC> >", 3582, G__RAT_Dict_847_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR(void) {
   /* vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_851_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_851_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_851_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_851_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_851_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_851_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_851_0_7, 107, -1, G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_851_0_8, 107, -1, G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_851_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_851_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - sz u 'RAT::DS::MCEV' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_851_0_11, 107, -1, G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_851_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_851_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_851_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), G__defined_typename("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >",3766,G__RAT_Dict_851_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >",3766,G__RAT_Dict_851_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n u 'RAT::DS::MCEV' - 11 'RAT::DS::MCEV()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >",3766,G__RAT_Dict_851_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >",3766,G__RAT_Dict_851_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator' 10 - first u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_851_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_851_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_851_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_851_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMCEV), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_851_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::MCEV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_851_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_851_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - position u 'RAT::DS::MCEV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_851_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - position u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_851_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - position k - 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::size_type' 0 - n "
"u 'RAT::DS::MCEV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_851_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_851_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_851_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - first u 'vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_851_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >", 3892, G__RAT_Dict_851_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR(void) {
   /* vector<RAT::DS::EV,allocator<RAT::DS::EV> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_855_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_855_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_855_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_855_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_855_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_855_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_855_0_7, 107, -1, G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_855_0_8, 107, -1, G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_855_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_855_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - sz u 'RAT::DS::EV' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_855_0_11, 107, -1, G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_855_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_855_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_855_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), G__defined_typename("vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::EV,allocator<RAT::DS::EV> >",3478,G__RAT_Dict_855_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::EV,allocator<RAT::DS::EV> >",3478,G__RAT_Dict_855_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n u 'RAT::DS::EV' - 11 'RAT::DS::EV()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::EV,allocator<RAT::DS::EV> >",3478,G__RAT_Dict_855_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::EV,allocator<RAT::DS::EV> >",3478,G__RAT_Dict_855_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator' 10 - first u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_855_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_855_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_855_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_855_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEV), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_855_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::EV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_855_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_855_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - position u 'RAT::DS::EV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_855_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - position u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_855_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - position k - 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::size_type' 0 - n "
"u 'RAT::DS::EV' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_855_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_855_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_855_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - first u 'vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_855_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::EV,allocator<RAT::DS::EV> >", 3604, G__RAT_Dict_855_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR(void) {
   /* vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_859_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_859_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_859_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_859_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_859_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_859_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_859_0_7, 107, -1, G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_859_0_8, 107, -1, G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_859_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_859_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - sz u 'RAT::DS::HeaderInfo' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_859_0_11, 107, -1, G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_859_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_859_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_859_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), G__defined_typename("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >",5130,G__RAT_Dict_859_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >",5130,G__RAT_Dict_859_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n u 'RAT::DS::HeaderInfo' - 11 'RAT::DS::HeaderInfo()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >",5130,G__RAT_Dict_859_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >",5130,G__RAT_Dict_859_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator' 10 - first u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_859_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_859_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_859_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_859_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_859_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::HeaderInfo' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_859_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_859_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - position u 'RAT::DS::HeaderInfo' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_859_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - position u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator' 10 - first "
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_859_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - position k - 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::size_type' 0 - n "
"u 'RAT::DS::HeaderInfo' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_859_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_859_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_859_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - first u 'vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_859_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >", 5256, G__RAT_Dict_859_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLSOCPMT(void) {
   /* RAT::DS::SOCPMT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT));
   G__memfunc_setup("SOCPMT",470,G__RAT_Dict_862_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SOCPMT",470,G__RAT_Dict_862_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetID",441,G__RAT_Dict_862_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__RAT_Dict_862_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLCN",509,G__RAT_Dict_862_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTime",664,G__RAT_Dict_862_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimes",802,G__RAT_Dict_862_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQHL",494,G__RAT_Dict_862_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - qhl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHLs",632,G__RAT_Dict_862_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQHS",501,G__RAT_Dict_862_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - qhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHSs",639,G__RAT_Dict_862_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTOFManipulator",1697,G__RAT_Dict_862_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTOFManipulator",1685,G__RAT_Dict_862_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPromptOccupancy",1875,G__RAT_Dict_862_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - occupancy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPromptOccupancy",1863,G__RAT_Dict_862_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShadowRelativeOccupancy",2675,G__RAT_Dict_862_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - occupancy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShadowRelativeOccupancy",2663,G__RAT_Dict_862_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRopeShadowRelativeOccupancy",3081,G__RAT_Dict_862_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - occupancy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRopeShadowRelativeOccupancy",3069,G__RAT_Dict_862_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTimeCentroid",1523,G__RAT_Dict_862_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 10 - centroid f - 'Float_t' 10 - error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimeCentroid",1511,G__RAT_Dict_862_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimeCentroidError",2033,G__RAT_Dict_862_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPeakFindOK",1224,G__RAT_Dict_862_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RAT::DS::SOCPMT::EPeakFindStatus' - 10 - ok", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPeakFindOK",1212,G__RAT_Dict_862_0_24, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__RAT_Dict_862_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOCPMT' - 11 - socpmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_862_0_26, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::SOCPMT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_862_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOCPMT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_862_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::SOCPMT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_862_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::SOCPMT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_862_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_862_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOCPMT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_862_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::SOCPMT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_862_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOCPMT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_862_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::SOCPMT::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SOCPMT", 470, G__RAT_Dict_862_0_38, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOCPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SOCPMT", 596, G__RAT_Dict_862_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_862_0_40, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::SOCPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDScLcLSOC(void) {
   /* RAT::DS::SOC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC));
   G__memfunc_setup("SOC",229,G__RAT_Dict_864_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCPMT",758,G__RAT_Dict_864_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCPMT",758,G__RAT_Dict_864_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCPMTIDs",1014,G__RAT_Dict_864_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<UInt_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SOCPMTExists",1110,G__RAT_Dict_864_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSOCPMT",735,G__RAT_Dict_864_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOCPMT' - 11 - pmt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneSOCPMTs",1107,G__RAT_Dict_864_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSourceID",1066,G__RAT_Dict_864_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSourceID",1054,G__RAT_Dict_864_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRunID",750,G__RAT_Dict_864_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunID",738,G__RAT_Dict_864_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalTimeOffset",1907,G__RAT_Dict_864_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 10 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalTimeOffset",1895,G__RAT_Dict_864_0_13, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNPulsesTriggered",1939,G__RAT_Dict_864_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 10 - nPulses", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNPulsesTriggered",1927,G__RAT_Dict_864_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitNames",1079,G__RAT_Dict_864_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitResult",1218,G__RAT_Dict_864_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLFitResult), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitResult",1230,G__RAT_Dict_864_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name u 'RAT::DS::FitResult' - 11 - fitResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalib",763,G__RAT_Dict_864_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCalib",763,G__RAT_Dict_864_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLCalib), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__RAT_Dict_864_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOC' - 11 - soc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_864_0_22, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DS::SOC::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_864_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOC::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_864_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DS::SOC::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_864_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DS::SOC::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_864_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_864_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOC::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_864_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::SOC::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_864_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DS::SOC::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_864_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DS::SOC::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SOC", 229, G__RAT_Dict_864_0_34, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOC' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SOC", 355, G__RAT_Dict_864_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_864_0_36, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::SOC' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR(void) {
   /* map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR));
   G__memfunc_setup("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >",9297,G__RAT_Dict_867_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >",9297,G__RAT_Dict_867_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >",9297,G__RAT_Dict_867_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >",9297,G__RAT_Dict_867_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_867_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_867_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_867_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_867_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_867_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_867_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_867_0_11, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_867_0_12, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_867_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT), -1, 1, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_867_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::SOCPMT>' 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_867_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - position u 'pair<unsigned int,RAT::DS::SOCPMT>' 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_867_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_867_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator' - 0 - first u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_867_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_867_0_19, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::size_type"), 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_867_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - first u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_867_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_867_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_867_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_867_0_24, 107, -1, G__defined_typename("map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::size_type"), 0, 1, 1, 1, 8, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_867_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_867_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "h - - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >", 9423, G__RAT_Dict_867_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR(void) {
   /* pair<unsigned int,RAT::DS::SOCPMT> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR));
   G__memfunc_setup("pair<unsigned int,RAT::DS::SOCPMT>",2902,G__RAT_Dict_868_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pair<unsigned int,RAT::DS::SOCPMT>",2902,G__RAT_Dict_868_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR), -1, 0, 2, 1, 1, 0, 
"h - - 11 - a u 'RAT::DS::SOCPMT' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR), -1, 1, 1, 1, 4, 0, "u 'pair<unsigned int,RAT::DS::SOCPMT>' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("pair<unsigned int,RAT::DS::SOCPMT>", 2902, G__RAT_Dict_868_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR), -1, 0, 1, 1, 1, 0, "u 'pair<unsigned int,RAT::DS::SOCPMT>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pair<unsigned int,RAT::DS::SOCPMT>", 3028, G__RAT_Dict_868_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLDataCleaningBits(void) {
   /* RAT::DU::DataCleaningBits */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_879_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitName",960,G__RAT_Dict_879_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitIndex",1079,G__RAT_Dict_879_0_3, 107, -1, G__defined_typename("size_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapBegin",1059,G__RAT_Dict_879_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapLast",978,G__RAT_Dict_879_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapEnd",853,G__RAT_Dict_879_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapBegin",1791,G__RAT_Dict_879_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapLast",1710,G__RAT_Dict_879_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapEnd",1585,G__RAT_Dict_879_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpNames",906,G__RAT_Dict_879_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_879_0_11, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::DataCleaningBits::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_879_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataCleaningBits::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_879_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::DataCleaningBits::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_879_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::DataCleaningBits::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_879_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_879_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataCleaningBits::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_879_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DataCleaningBits::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_879_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataCleaningBits::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_879_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DataCleaningBits::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("DataCleaningBits", 1581, G__RAT_Dict_879_0_23, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DataCleaningBits", 1581, G__RAT_Dict_879_0_24, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::DataCleaningBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DataCleaningBits", 1707, G__RAT_Dict_879_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_879_0_26, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::DataCleaningBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLDataQualityBits(void) {
   /* RAT::DU::DataQualityBits */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_895_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitName",960,G__RAT_Dict_895_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitIndex",1079,G__RAT_Dict_895_0_3, 107, -1, G__defined_typename("size_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapBegin",1059,G__RAT_Dict_895_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapLast",978,G__RAT_Dict_895_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMapEnd",853,G__RAT_Dict_895_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapBegin",1791,G__RAT_Dict_895_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapLast",1710,G__RAT_Dict_895_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseMapEnd",1585,G__RAT_Dict_895_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpNames",906,G__RAT_Dict_895_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_895_0_11, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::DataQualityBits::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_895_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataQualityBits::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_895_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::DataQualityBits::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_895_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::DataQualityBits::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_895_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_895_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataQualityBits::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_895_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DataQualityBits::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_895_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DataQualityBits::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_895_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DataQualityBits::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("DataQualityBits", 1525, G__RAT_Dict_895_0_23, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DataQualityBits", 1525, G__RAT_Dict_895_0_24, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::DataQualityBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DataQualityBits", 1651, G__RAT_Dict_895_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_895_0_26, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::DataQualityBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLChanSWStatus(void) {
   /* RAT::DU::ChanSWStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus));
   G__memfunc_setup("ChanSWStatus",1192,G__RAT_Dict_897_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_897_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTubeStable",1191,G__RAT_Dict_897_0_3, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitName",960,G__RAT_Dict_897_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitIndex",1079,G__RAT_Dict_897_0_5, 107, -1, G__defined_typename("size_t"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpNames",906,G__RAT_Dict_897_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitNames",1075,G__RAT_Dict_897_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBitMap",861,G__RAT_Dict_897_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR), G__defined_typename("map<std::string,size_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverseBitMap",1593,G__RAT_Dict_897_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR), G__defined_typename("map<size_t,std::string>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_897_0_10, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::ChanSWStatus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_897_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanSWStatus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_897_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::ChanSWStatus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_897_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::ChanSWStatus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_897_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_897_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanSWStatus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_897_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::ChanSWStatus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_897_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanSWStatus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_897_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::ChanSWStatus::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ChanSWStatus", 1192, G__RAT_Dict_897_0_22, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ChanSWStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ChanSWStatus", 1318, G__RAT_Dict_897_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_897_0_24, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ChanSWStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLTrigBits(void) {
   /* RAT::DU::TrigBits */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_899_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::TrigBits::BeginOfRun) ), 0);
   G__memfunc_setup("GetBitName",960,G__RAT_Dict_899_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) G__func2void( (string (*)(const size_t))(&RAT::DU::TrigBits::GetBitName) ), 0);
   G__memfunc_setup("GetBitIndex",1079,G__RAT_Dict_899_0_3, 107, -1, G__defined_typename("size_t"), 0, 1, 3, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) G__func2void( (size_t (*)(const string&))(&RAT::DU::TrigBits::GetBitIndex) ), 0);
   G__memfunc_setup("GetMask",684,G__RAT_Dict_899_0_4, 104, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - names", (char*)NULL, (void*) G__func2void( (unsigned int (*)(const string&))(&RAT::DU::TrigBits::GetMask) ), 0);
   G__memfunc_setup("DumpNames",906,G__RAT_Dict_899_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::TrigBits::DumpNames) ), 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_899_0_6, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::TrigBits::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_899_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TrigBits::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_899_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::TrigBits::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_899_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::TrigBits::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_899_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_899_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TrigBits::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_899_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::TrigBits::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_899_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TrigBits::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_899_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::TrigBits::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TrigBits", 808, G__RAT_Dict_899_0_18, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TrigBits", 808, G__RAT_Dict_899_0_19, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::TrigBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrigBits", 934, G__RAT_Dict_899_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_899_0_21, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::TrigBits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLDSReader(void) {
   /* RAT::DU::DSReader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader));
   G__memfunc_setup("DSReader",746,G__RAT_Dict_975_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - filename g - - 10 'true' useMeta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DSReader",746,G__RAT_Dict_975_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader), -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - filenames g - - 10 'true' useMeta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_975_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__RAT_Dict_975_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__RAT_Dict_975_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry), -1, 1, 1, 1, 1, 1, "k - 'size_t' 10 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryCount",1339,G__RAT_Dict_975_0_6, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRun",597,G__RAT_Dict_975_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunByRunID",1234,G__RAT_Dict_975_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 1, 1, 1, 1, "h - - 10 - runID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunByIndex",1288,G__RAT_Dict_975_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 1, 1, 1, 1, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunCount",1118,G__RAT_Dict_975_0_10, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMeta",679,G__RAT_Dict_975_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_975_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::DSReader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_975_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DSReader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_975_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::DSReader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_975_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::DSReader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_975_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_975_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DSReader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_975_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DSReader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_975_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::DSReader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_975_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::DSReader::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("DSReader", 746, G__RAT_Dict_975_0_24, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::DSReader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DSReader", 872, G__RAT_Dict_975_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_975_0_26, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDSReader), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::DSReader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLEffectiveVelocity(void) {
   /* RAT::DU::EffectiveVelocity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_976_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcByDistance",1369,G__RAT_Dict_976_0_2, 100, -1, -1, 0, 3, 1, 1, 8, 
"d - - 10 - distInInnerAV d - - 10 - distInAV "
"d - - 10 - distInWater", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInnerAVVelocity",1794,G__RAT_Dict_976_0_3, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVVelocity",1286,G__RAT_Dict_976_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaterVelocity",1650,G__RAT_Dict_976_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,G__RAT_Dict_976_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_976_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::EffectiveVelocity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_976_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EffectiveVelocity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_976_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::EffectiveVelocity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_976_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::EffectiveVelocity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_976_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_976_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EffectiveVelocity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_976_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::EffectiveVelocity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_976_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EffectiveVelocity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_976_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::EffectiveVelocity::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("EffectiveVelocity", 1760, G__RAT_Dict_976_0_19, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("EffectiveVelocity", 1760, G__RAT_Dict_976_0_20, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::EffectiveVelocity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EffectiveVelocity", 1886, G__RAT_Dict_976_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_976_0_22, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::EffectiveVelocity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDBTable(void) {
   /* RAT::DBTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable));
   G__memfunc_setup("DBTable",622,G__RAT_Dict_1029_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DBTable",622,G__RAT_Dict_1029_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 '\"\"' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DBTable",622,G__RAT_Dict_1029_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 1, 0, 
"u 'json::Value' - 1 - init k - 'size_t' 10 '0' size_bytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveAs",579,G__RAT_Dict_1029_0_4, 121, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 0 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__RAT_Dict_1029_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,G__RAT_Dict_1029_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - _tblname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__RAT_Dict_1029_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIndex",804,G__RAT_Dict_1029_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - _index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunBegin",1082,G__RAT_Dict_1029_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunEnd",876,G__RAT_Dict_1029_0_10, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPassNumber",1312,G__RAT_Dict_1029_0_11, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUser",603,G__RAT_Dict_1029_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDefault",897,G__RAT_Dict_1029_0_13, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValidRun",993,G__RAT_Dict_1029_0_14, 103, -1, -1, 0, 1, 1, 1, 0, "i - - 10 - run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRunRange",1102,G__RAT_Dict_1029_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - _run_begin i - - 0 - _run_end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPassNumber",1324,G__RAT_Dict_1029_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUser",715,G__RAT_Dict_1029_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefault",1009,G__RAT_Dict_1029_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFieldType",1190,G__RAT_Dict_1029_0_19, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType), -1, 0, 1, 1, 1, 8, "u 'string' - 0 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFieldList",1184,G__RAT_Dict_1029_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetI",361,G__RAT_Dict_1029_0_21, 105, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetD",356,G__RAT_Dict_1029_0_22, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetS",371,G__RAT_Dict_1029_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__RAT_Dict_1029_0_24, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIArray",872,G__RAT_Dict_1029_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDArray",867,G__RAT_Dict_1029_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSArray",882,G__RAT_Dict_1029_0_27, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZArray",889,G__RAT_Dict_1029_0_28, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEboolcOallocatorlEboolgRsPgR), G__defined_typename("vector<bool>"), 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetJSON",602,G__RAT_Dict_1029_0_29, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetI",373,G__RAT_Dict_1029_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name i - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetD",368,G__RAT_Dict_1029_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetS",383,G__RAT_Dict_1029_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name u 'string' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_1029_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name g - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIArray",884,G__RAT_Dict_1029_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name u 'vector<int,allocator<int> >' 'vector<int>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDArray",879,G__RAT_Dict_1029_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name u 'vector<double,allocator<double> >' 'vector<double>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSArray",894,G__RAT_Dict_1029_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZArray",901,G__RAT_Dict_1029_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - name u 'vector<bool,allocator<bool> >' 'vector<bool>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetJSON",614,G__RAT_Dict_1029_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name u 'json::Value' - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBytes",807,G__RAT_Dict_1029_0_39, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRawJSONTable",1388,G__RAT_Dict_1029_0_40, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get<int>",741,G__RAT_Dict_1029_0_41, 105, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get<double>",1045,G__RAT_Dict_1029_0_42, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get<bool>",838,G__RAT_Dict_1029_0_43, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DBTable", 622, G__RAT_Dict_1029_0_44, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 1, 1, 1, 0, "u 'RAT::DBTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DBTable", 748, G__RAT_Dict_1029_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1029_0_46, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 1, 1, 1, 0, "u 'RAT::DBTable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDB(void) {
   /* RAT::DB */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB));
   G__memfunc_setup("Get",288,G__RAT_Dict_1043_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (RAT::DB* (*)())(&RAT::DB::Get) ), 0);
   G__memfunc_setup("ParseTableName",1380,G__RAT_Dict_1043_0_2, 103, -1, -1, 0, 3, 3, 1, 0, 
"u 'string' - 11 - descriptor u 'string' - 1 - table "
"u 'string' - 1 - index", (char*)NULL, (void*) G__func2void( (bool (*)(const string&, string&, string&))(&RAT::DB::ParseTableName) ), 0);
   G__memfunc_setup("ParseFieldName",1376,G__RAT_Dict_1043_0_3, 103, -1, -1, 0, 3, 3, 1, 0, 
"u 'string' - 0 - descriptor u 'string' - 1 - field "
"i - - 1 - index", (char*)NULL, (void*) G__func2void( (bool (*)(string, string&, int&))(&RAT::DB::ParseFieldName) ), 0);
   G__memfunc_setup("ReadRATDBFile",1129,G__RAT_Dict_1043_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), G__defined_typename("vector<RAT::DBTable*>"), 0, 1, 3, 1, 0, "u 'string' - 11 - filename", (char*)NULL, (void*) G__func2void( (vector<RAT::DBTable*> (*)(const string&))(&RAT::DB::ReadRATDBFile) ), 0);
   G__memfunc_setup("GetTableKey",1073,G__RAT_Dict_1043_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTableKey), -1, 0, 1, 3, 1, 0, "U 'RAT::DBTable' - 10 - table", (char*)NULL, (void*) G__func2void( (RAT::DBTableKey (*)(const RAT::DBTable*))(&RAT::DB::GetTableKey) ), 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1043_0_6, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DB::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1043_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DB::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1043_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DB::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1043_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DB::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__RAT_Dict_1043_0_10, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__RAT_Dict_1043_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__RAT_Dict_1043_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1043_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1043_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DB::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1043_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DB::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1043_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DB::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1043_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DB::DeclFileLine) ), 0);
   G__memfunc_setup("DB",134,G__RAT_Dict_1043_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitBackend",1084,G__RAT_Dict_1043_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefreshTablesOnServer",2142,G__RAT_Dict_1043_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 10 '0' run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1043_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Run' - 1 - run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndOfBeginOfRun",1435,G__RAT_Dict_1043_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndOfRun",769,G__RAT_Dict_1043_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DS::Run' - 1 - run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSetFieldUsage",1763,G__RAT_Dict_1043_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckLoadedTables",1666,G__RAT_Dict_1043_0_25, 103, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >' - 11 - contents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Load",384,G__RAT_Dict_1043_0_26, 105, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 10 - filename g - - 0 'false' printPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadFile",768,G__RAT_Dict_1043_0_27, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadAll",665,G__RAT_Dict_1043_0_28, 105, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 10 - dirname u 'string' - 0 '\"*.ratdb\"' pattern", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadDefaults",1208,G__RAT_Dict_1043_0_29, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__RAT_Dict_1043_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AllowDanger",1104,G__RAT_Dict_1043_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadDefaultPlaneLocks",2097,G__RAT_Dict_1043_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetServer",931,G__RAT_Dict_1043_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - url g - - 0 'true' init", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLink",686,G__RAT_Dict_1043_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), G__defined_typename("RAT::DBLinkPtr"), 0, 3, 1, 1, 0, 
"u 'string' - 10 - tblname u 'string' - 0 '\"\"' index "
"i - - 0 '-1' pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLinkGroup",1211,G__RAT_Dict_1043_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR), G__defined_typename("RAT::DBLinkGroup"), 0, 1, 1, 1, 0, "u 'string' - 10 - tblname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTblNoDefaultPlane",1949,G__RAT_Dict_1043_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - tblname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveTblNoDefaultPlane",2306,G__RAT_Dict_1043_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - tblname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultPlaneLockStatus",2542,G__RAT_Dict_1043_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - enable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTblNoDefaultPlane",1972,G__RAT_Dict_1043_0_39, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR), G__defined_typename("vector<std::pair<std::string,std::string> >"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTblNoDefaultPlaneStatus",2616,G__RAT_Dict_1043_0_40, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - tblname u 'string' - 11 '\"\"' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UploadTableOnline",1714,G__RAT_Dict_1043_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DBTable' - 1 - tbl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDbTag",750,G__RAT_Dict_1043_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - tag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDBTag",706,G__RAT_Dict_1043_0_43, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValidField",1168,G__RAT_Dict_1043_0_44, 103, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValidFieldType",1586,G__RAT_Dict_1043_0_45, 103, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname i - - 0 - valfieldtype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetI",373,G__RAT_Dict_1043_0_46, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"i - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetI",373,G__RAT_Dict_1043_0_47, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname i - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetD",368,G__RAT_Dict_1043_0_48, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetD",368,G__RAT_Dict_1043_0_49, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetS",383,G__RAT_Dict_1043_0_50, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"u 'string' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetS",383,G__RAT_Dict_1043_0_51, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname u 'string' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_1043_0_52, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"g - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_1043_0_53, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname g - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIArray",884,G__RAT_Dict_1043_0_54, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"u 'vector<int,allocator<int> >' 'vector<int>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIArray",884,G__RAT_Dict_1043_0_55, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname u 'vector<int,allocator<int> >' 'vector<int>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIValInArray",1358,G__RAT_Dict_1043_0_56, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"k - 'size_t' 0 - position i - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIValInArray",1358,G__RAT_Dict_1043_0_57, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname k - 'size_t' 0 - position "
"i - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDArray",879,G__RAT_Dict_1043_0_58, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDArray",879,G__RAT_Dict_1043_0_59, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname u 'vector<double,allocator<double> >' 'vector<double>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDValInArray",1353,G__RAT_Dict_1043_0_60, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"k - 'size_t' 0 - position d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDValInArray",1353,G__RAT_Dict_1043_0_61, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname k - 'size_t' 0 - position "
"d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSArray",894,G__RAT_Dict_1043_0_62, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSArray",894,G__RAT_Dict_1043_0_63, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSValInArray",1368,G__RAT_Dict_1043_0_64, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"k - 'size_t' 0 - position u 'string' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSValInArray",1368,G__RAT_Dict_1043_0_65, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname k - 'size_t' 0 - position "
"u 'string' - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZArray",901,G__RAT_Dict_1043_0_66, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"u 'vector<bool,allocator<bool> >' 'vector<bool>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZArray",901,G__RAT_Dict_1043_0_67, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname u 'vector<bool,allocator<bool> >' 'vector<bool>' 11 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZValInArray",1375,G__RAT_Dict_1043_0_68, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - fieldname "
"k - 'size_t' 0 - position g - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZValInArray",1375,G__RAT_Dict_1043_0_69, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 - index "
"u 'string' - 0 - fieldname k - 'size_t' 0 - position "
"g - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserTable",1191,G__RAT_Dict_1043_0_70, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 1, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunTable",1085,G__RAT_Dict_1043_0_71, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 4, 1, 1, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index "
"i - - 0 - runNumber i - - 0 '-1' passNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultTable",1485,G__RAT_Dict_1043_0_72, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 1, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLink",1020,G__RAT_Dict_1043_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::DBLink' - 0 - link", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumLinks",817,G__RAT_Dict_1043_0_74, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FloatToDoubleArray",1811,G__RAT_Dict_1043_0_75, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 3, 1, 0, "u 'vector<float,allocator<float> >' 'vector<float>' 11 - in", (char*)NULL, (void*) G__func2void( (vector<double> (*)(const vector<float>&))(&RAT::DB::FloatToDoubleArray) ), 0);
   G__memfunc_setup("SetRunID",750,G__RAT_Dict_1043_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 10 - aRun", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunID",738,G__RAT_Dict_1043_0_77, 104, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPassDBEntry",1371,G__RAT_Dict_1043_0_78, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - tblname u 'string' - 11 - index "
"i - - 0 - pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPassDBEntry",1359,G__RAT_Dict_1043_0_79, 105, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 0 - tblname u 'string' - 0 '\"\"' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAirplaneModeStatus",2145,G__RAT_Dict_1043_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' enable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAirplaneModeStatus",2133,G__RAT_Dict_1043_0_81, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AreDefaultsLoaded",1689,G__RAT_Dict_1043_0_82, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("decode_server",1370,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 2, 0, "u 'string' - 11 - original", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindAnyTableRemote",1789,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTableStructure",1850,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 3, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index "
"i - - 0 '-1' runNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTableUser",1288,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTableDefault",1582,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 2, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTableRun",1182,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 4, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index "
"i - - 10 - runNumber i - - 0 '1' passNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindOrCreateTable",1662,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 3, 1, 2, 0, 
"u 'string' - 10 - tblname u 'string' - 10 - index "
"i - - 0 - runNumber", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DB", 134, G__RAT_Dict_1043_0_90, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB), -1, 0, 1, 1, 1, 0, "u 'RAT::DB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DB", 260, G__RAT_Dict_1043_0_91, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1043_0_92, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDB), -1, 1, 1, 1, 1, 0, "u 'RAT::DB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDBLink(void) {
   /* RAT::DBLink */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink));
   G__memfunc_setup("DBLink",532,G__RAT_Dict_1044_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 4, 1, 1, 0, 
"U 'RAT::DB' - 0 - db u 'string' - 0 - tblname "
"u 'string' - 0 - index i - - 0 '-1' _pass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__RAT_Dict_1044_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__RAT_Dict_1044_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentRun",1348,G__RAT_Dict_1044_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - runNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetI",361,G__RAT_Dict_1044_0_5, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetD",356,G__RAT_Dict_1044_0_6, 100, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetS",371,G__RAT_Dict_1044_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__RAT_Dict_1044_0_8, 103, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIArray",872,G__RAT_Dict_1044_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFArrayFromD",1341,G__RAT_Dict_1044_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<float>"), 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DArrayToFArray",1355,G__RAT_Dict_1044_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<float>"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - input", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDArray",867,G__RAT_Dict_1044_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSArray",882,G__RAT_Dict_1044_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR), G__defined_typename("vector<std::string>"), 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZArray",889,G__RAT_Dict_1044_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEboolcOallocatorlEboolgRsPgR), G__defined_typename("vector<bool>"), 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetJSON",602,G__RAT_Dict_1044_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unlink",625,G__RAT_Dict_1044_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreLoadRunTable",1476,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DBLink", 532, G__RAT_Dict_1044_0_18, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 1, 1, 1, 0, "u 'RAT::DBLink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DBLink", 658, G__RAT_Dict_1044_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1044_0_20, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 1, 1, 1, 1, 0, "u 'RAT::DBLink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLPgSQLBackend(void) {
   /* RAT::PgSQLBackend */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend));
   G__memfunc_setup("PgSQLBackend",1103,G__RAT_Dict_1045_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend), -1, 0, 1, 1, 1, 0, "u 'string' - 11 '\"\"' conn_str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConnOpts",1120,G__RAT_Dict_1045_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - opts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConnOpts",1108,G__RAT_Dict_1045_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConnURL",941,G__RAT_Dict_1045_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - url", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConnURL",929,G__RAT_Dict_1045_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Disconnect",1034,G__RAT_Dict_1045_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Connect",714,G__RAT_Dict_1045_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertObject",1228,G__RAT_Dict_1045_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DBTable' - 1 - tbl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListIndexes",1420,G__RAT_Dict_1045_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR), G__defined_typename("set<std::string>"), 0, 2, 1, 1, 0, 
"u 'string' - 11 - type_name i - - 11 '0' run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTypes",1233,G__RAT_Dict_1045_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR), G__defined_typename("set<std::string>"), 0, 1, 1, 1, 0, "i - - 10 '0' run", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FetchObjFast",1171,G__RAT_Dict_1045_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - tblname u 'string' - 11 - index "
"g - - 1 - found k - 'size_t' 1 - size_bytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FetchObject",1089,G__RAT_Dict_1045_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_jsoncLcLValue), -1, 0, 6, 1, 1, 0, 
"u 'string' - 11 - tblname u 'string' - 11 - index "
"i - - 11 - runNumber i - - 11 - passNumber "
"g - - 1 - found k - 'size_t' 1 - size_bytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReconnectRetries",1963,G__RAT_Dict_1045_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 11 - nretries", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReconnRetries",1635,G__RAT_Dict_1045_0_14, 104, -1, -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoRCompleted",1484,G__RAT_Dict_1045_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoRCompleted",1472,G__RAT_Dict_1045_0_16, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDbTag",750,G__RAT_Dict_1045_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - tag", "{ratdb_tag_ = tag;}", (void*) NULL, 0);
   G__memfunc_setup("GetDbTag",738,G__RAT_Dict_1045_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckAndResetConn",1666,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearResultset",1458,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteSelectQuery",1865,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - query", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FailQuery",914,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - query", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("PgSQLBackend", 1103, G__RAT_Dict_1045_0_23, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend), -1, 0, 1, 1, 1, 0, "u 'RAT::PgSQLBackend' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PgSQLBackend", 1229, G__RAT_Dict_1045_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1045_0_25, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLPgSQLBackend), -1, 1, 1, 1, 1, 0, "u 'RAT::PgSQLBackend' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncsimple_ptr_nocopylERATcLcLDBTablegR(void) {
   /* simple_ptr_nocopy<RAT::DBTable> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR));
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBTable>",2937,G__RAT_Dict_1047_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBTable>",2937,G__RAT_Dict_1047_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR), -1, 0, 1, 1, 1, 0, "u 'simple_ptr_nocopy<RAT::DBTable>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1047_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR), -1, 1, 1, 1, 1, 0, "u 'simple_ptr_nocopy<RAT::DBTable>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBTable>",2937,G__RAT_Dict_1047_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR), -1, 0, 1, 5, 1, 0, "U 'RAT::DBTable' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1047_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR), -1, 1, 1, 1, 1, 0, "U 'RAT::DBTable' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator bool",1336,G__RAT_Dict_1047_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!",909,G__RAT_Dict_1047_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("present",769,G__RAT_Dict_1047_0_8, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("null",443,G__RAT_Dict_1047_0_9, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_1047_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_1047_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__RAT_Dict_1047_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__RAT_Dict_1047_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("value",541,G__RAT_Dict_1047_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("value",541,G__RAT_Dict_1047_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__RAT_Dict_1047_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::DBTable' - 0 '0' data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pointer",769,G__RAT_Dict_1047_0_17, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pointer",769,G__RAT_Dict_1047_0_18, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("aliases",738,G__RAT_Dict_1047_0_19, 103, -1, -1, 0, 1, 1, 1, 8, "u 'simple_ptr_nocopy<RAT::DBTable>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("alias_count",1170,G__RAT_Dict_1047_0_20, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1047_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~simple_ptr_nocopy<RAT::DBTable>", 3063, G__RAT_Dict_1047_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncsimple_ptr_nocopylERATcLcLDBLinkgR(void) {
   /* simple_ptr_nocopy<RAT::DBLink> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR));
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBLink>",2847,G__RAT_Dict_1057_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBLink>",2847,G__RAT_Dict_1057_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), -1, 0, 1, 1, 1, 0, "u 'simple_ptr_nocopy<RAT::DBLink>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1057_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), -1, 1, 1, 1, 1, 0, "u 'simple_ptr_nocopy<RAT::DBLink>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("simple_ptr_nocopy<RAT::DBLink>",2847,G__RAT_Dict_1057_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), -1, 0, 1, 5, 1, 0, "U 'RAT::DBLink' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1057_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR), -1, 1, 1, 1, 1, 0, "U 'RAT::DBLink' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator bool",1336,G__RAT_Dict_1057_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!",909,G__RAT_Dict_1057_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("present",769,G__RAT_Dict_1057_0_8, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("null",443,G__RAT_Dict_1057_0_9, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_1057_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 1, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__RAT_Dict_1057_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 1, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__RAT_Dict_1057_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__RAT_Dict_1057_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("value",541,G__RAT_Dict_1057_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 1, 0, 1, 1, 32, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("value",541,G__RAT_Dict_1057_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 1, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__RAT_Dict_1057_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::DBLink' - 0 '0' data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pointer",769,G__RAT_Dict_1057_0_17, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pointer",769,G__RAT_Dict_1057_0_18, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBLink), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("aliases",738,G__RAT_Dict_1057_0_19, 103, -1, -1, 0, 1, 1, 1, 8, "u 'simple_ptr_nocopy<RAT::DBLink>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("alias_count",1170,G__RAT_Dict_1057_0_20, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1057_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~simple_ptr_nocopy<RAT::DBLink>", 2973, G__RAT_Dict_1057_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR(void) {
   /* vector<RAT::DBTable*,allocator<RAT::DBTable*> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_1066_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_1066_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_1066_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_1066_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_1066_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_1066_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_1066_0_7, 107, -1, G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_1066_0_8, 107, -1, G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1066_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1066_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - sz U 'RAT::DBTable' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_1066_0_11, 107, -1, G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_1066_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1066_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1066_0_14, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable*,allocator<RAT::DBTable*> >",3962,G__RAT_Dict_1066_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable*,allocator<RAT::DBTable*> >",3962,G__RAT_Dict_1066_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n U 'RAT::DBTable' - 41 '(RAT::DBTable*)()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable*,allocator<RAT::DBTable*> >",3962,G__RAT_Dict_1066_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable*,allocator<RAT::DBTable*> >",3962,G__RAT_Dict_1066_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator' 10 - first u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1066_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_1066_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_1066_0_21, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_1066_0_22, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_1066_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::DBTable' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_1066_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1066_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - position U 'RAT::DBTable' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1066_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - position u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator' 10 - first "
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1066_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - position k - 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::size_type' 0 - n "
"U 'RAT::DBTable' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_1066_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1066_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1066_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - first u 'vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1066_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DBTable*,allocator<RAT::DBTable*> >", 4088, G__RAT_Dict_1066_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLGroupVelocity(void) {
   /* RAT::DU::GroupVelocity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1098_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcByDistance",1369,G__RAT_Dict_1098_0_2, 100, -1, -1, 0, 3, 1, 1, 8, 
"d - - 10 - distInInnerAV d - - 10 - distInAV "
"d - - 10 - distInWater", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcByDistance",1369,G__RAT_Dict_1098_0_3, 100, -1, -1, 0, 4, 1, 1, 8, 
"d - - 10 - distInInnerAV d - - 10 - distInAV "
"d - - 10 - distInWater d - - 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PMTBucketTime",1246,G__RAT_Dict_1098_0_4, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - incidentAngle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1098_0_5, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::GroupVelocity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1098_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::GroupVelocity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1098_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::GroupVelocity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1098_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::GroupVelocity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1098_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1098_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::GroupVelocity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1098_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::GroupVelocity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1098_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::GroupVelocity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1098_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::GroupVelocity::DeclFileLine) ), 0);
   G__memfunc_setup("LoadGroupVelocity",1756,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'simple_ptr_nocopy<RAT::DBLink>' 'RAT::DBLinkPtr' 0 - dbTable u 'TGraph' - 1 - property", (char*)NULL, (void*) NULL, 0);
   // automatic default constructor
   G__memfunc_setup("GroupVelocity", 1372, G__RAT_Dict_1098_0_18, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("GroupVelocity", 1372, G__RAT_Dict_1098_0_19, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::GroupVelocity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GroupVelocity", 1498, G__RAT_Dict_1098_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1098_0_21, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::GroupVelocity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLLightPathCalculator(void) {
   /* RAT::DU::LightPathCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator));
   G__memfunc_setup("LightPathCalculator",1935,G__RAT_Dict_1100_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1100_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadRefractiveIndex",1923,G__RAT_Dict_1100_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'simple_ptr_nocopy<RAT::DBLink>' 'RAT::DBLinkPtr' 0 - dbTable u 'TGraph' - 1 - property", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetValues",1139,G__RAT_Dict_1100_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcByPosition",1411,G__RAT_Dict_1100_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TVector3' - 11 - eventPos u 'TVector3' - 11 - pmtPos "
"d - 'Double_t' 10 '3.103125*1e-6' energyMeV d - 'Double_t' 10 '0.0' localityVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcByPositionPartial",2128,G__RAT_Dict_1100_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TVector3' - 11 - eventPos u 'TVector3' - 11 - pmtPos "
"d - 'Double_t' 10 '3.103125*1e-6' energy d - 'Double_t' 10 '0.0' localityVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateSolidAngle",1904,G__RAT_Dict_1100_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVector3' - 11 - pmtNorm h - 'UInt_t' 10 - nVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateCosThetaPMT",1946,G__RAT_Dict_1100_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 10 - pmtID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateFresnelTRCoeff",2278,G__RAT_Dict_1100_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateParallelTransmissionCoefficient",4132,G__RAT_Dict_1100_0_10, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - incRI d - 'Double_t' 10 - refRI "
"d - 'Double_t' 10 - incAngle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculatePerpendicularTransmissionCoefficient",4677,G__RAT_Dict_1100_0_11, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 10 - incRI d - 'Double_t' 10 - refRI "
"d - 'Double_t' 10 - incAngle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInnerAVRI",1102,G__RAT_Dict_1100_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperTargetRI",1582,G__RAT_Dict_1100_0_13, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerTargetRI",1579,G__RAT_Dict_1100_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVRI",594,G__RAT_Dict_1100_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWaterRI",958,G__RAT_Dict_1100_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLoopCeiling",1397,G__RAT_Dict_1100_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFinalLoopValue",1697,G__RAT_Dict_1100_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTIR",527,G__RAT_Dict_1100_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResvHit",997,G__RAT_Dict_1100_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathValid",1181,G__RAT_Dict_1100_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXAVNeck",912,G__RAT_Dict_1100_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStraightLine",1518,G__RAT_Dict_1100_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetELLIEEvent",1165,G__RAT_Dict_1100_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPathPrecision",1625,G__RAT_Dict_1100_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergy",906,G__RAT_Dict_1100_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInInnerAV",1534,G__RAT_Dict_1100_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInAV",1026,G__RAT_Dict_1100_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInWater",1390,G__RAT_Dict_1100_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInUpperTarget",2014,G__RAT_Dict_1100_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInLowerTarget",2011,G__RAT_Dict_1100_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInNeckInnerAV",1919,G__RAT_Dict_1100_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInNeckAV",1411,G__RAT_Dict_1100_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistInNeckWater",1775,G__RAT_Dict_1100_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalDist",1208,G__RAT_Dict_1100_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalDistPartial",1925,G__RAT_Dict_1100_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSolidAngle",1282,G__RAT_Dict_1100_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCosThetaAvg",1369,G__RAT_Dict_1100_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFresnelTCoeff",1574,G__RAT_Dict_1100_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFresnelRCoeff",1572,G__RAT_Dict_1100_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStartPos",1120,G__RAT_Dict_1100_0_41, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndPos",873,G__RAT_Dict_1100_0_42, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightPathEndPos",1774,G__RAT_Dict_1100_0_43, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOnPMT",1818,G__RAT_Dict_1100_0_44, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitialLightVec",1792,G__RAT_Dict_1100_0_45, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnAV1st",1430,G__RAT_Dict_1100_0_46, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnAV2nd",1410,G__RAT_Dict_1100_0_47, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnAV3rd",1415,G__RAT_Dict_1100_0_48, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnAV4th",1422,G__RAT_Dict_1100_0_49, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnNeck1st",1664,G__RAT_Dict_1100_0_50, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointOnNeck2nd",1644,G__RAT_Dict_1100_0_51, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightPathType",1607,G__RAT_Dict_1100_0_52, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOn1stSurf",2273,G__RAT_Dict_1100_0_53, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOn2ndSurf",2253,G__RAT_Dict_1100_0_54, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOn3rdSurf",2258,G__RAT_Dict_1100_0_55, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOn4thSurf",2265,G__RAT_Dict_1100_0_56, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVInnerRadius",1563,G__RAT_Dict_1100_0_57, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVOuterRadius",1582,G__RAT_Dict_1100_0_58, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckInnerRadius",1797,G__RAT_Dict_1100_0_59, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckOuterRadius",1816,G__RAT_Dict_1100_0_60, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMTRadius",1145,G__RAT_Dict_1100_0_61, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStartPos",1132,G__RAT_Dict_1100_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - startPos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEndPos",885,G__RAT_Dict_1100_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - endPos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetELLIEEvent",1177,G__RAT_Dict_1100_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 10 - reflect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1100_0_65, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::LightPathCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1100_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::LightPathCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1100_0_67, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::LightPathCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1100_0_68, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::LightPathCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1100_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1100_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::LightPathCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1100_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::LightPathCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1100_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::LightPathCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1100_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::LightPathCalculator::DeclFileLine) ), 0);
   G__memfunc_setup("Theta1st",782,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DTheta1st",850,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta2nd",762,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DTheta2nd",830,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta3rd",767,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DTheta3rd",835,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta4th",774,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DTheta4th",842,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta5th",775,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DTheta5th",843,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ThetaResidual",1327,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DThetaResidual",1395,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 10 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FuncD",464,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"d - 'Double_t' 0 - theta d - 'Double_t' 1 - funcVal "
"d - 'Double_t' 1 - dFuncVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RTSafe",549,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - x2 "
"d - 'Double_t' 0 - xAcc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateDistancesInnerAV",2495,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - eventPos u 'TVector3' - 11 - pmtPos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateDistancesOutsideAV",2720,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - eventPos u 'TVector3' - 11 - pmtPos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PathCalculation",1532,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TVector3' - 11 - initOffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadjustOffset",1449,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - distWater u 'TVector3' - 1 - initOffset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalityCheck",1311,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClosestAngle",1220,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - eventPos d - 'Double_t' 10 - edgeRadius", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReflectionAngle",1522,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - eventPos d - 'Double_t' 10 - edgeRadius", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PathRefraction",1434,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - incidentVec u 'TVector3' - 11 - incidentSurfVec "
"d - 'Double_t' 10 - incRIndex d - 'Double_t' 10 - refRIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VectorToSphereEdge",1810,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - startPos u 'TVector3' - 11 - startDir "
"d - 'Double_t' 10 - radiusFromCentre g - 'Bool_t' 10 - outside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VectorToCylinderEdge",2021,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - startPos u 'TVector3' - 11 - startDir "
"u 'TVector3' - 11 - cylinderBaseOrigin d - 'Double_t' 10 - cylinderRadius", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PathThroughTarget",1749,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - enterPos u 'TVector3' - 11 - enterDir "
"u 'TVector3' - 1 - exitPos u 'TVector3' - 1 - exitDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PathCalculationPartial",2249,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TVector3' - 11 - initialDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAVNeckInformation",1994,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - pointOnAV u 'TVector3' - 11 - dirVec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateSolidAnglePolygon",2648,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - pmtNorm h - 'UInt_t' 10 - nVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FresnelTRCoeff",1368,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"u 'TVector3' - 11 - dir u 'TVector3' - 11 - norm "
"d - 'Double_t' 10 - n1 d - 'Double_t' 10 - n2 "
"d - 'Double_t' 1 - T d - 'Double_t' 1 - R", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTIR",539,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 10 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResvHit",1009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 10 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterpolateTGraph",1741,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"u 'TGraph' - 11 - graph d - 'Double_t' 10 - energy", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("LightPathCalculator", 1935, G__RAT_Dict_1100_0_109, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LightPathCalculator", 2061, G__RAT_Dict_1100_0_110, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1100_0_111, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLPanelInfo(void) {
   /* RAT::DU::PanelInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1110_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__RAT_Dict_1110_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPanelNumber",1401,G__RAT_Dict_1110_0_3, 105, -1, -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__RAT_Dict_1110_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__RAT_Dict_1110_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 1, 1, 1, 8, "k - 'size_t' 10 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCount",809,G__RAT_Dict_1110_0_6, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1110_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::PanelInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1110_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PanelInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1110_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::PanelInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1110_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::PanelInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1110_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1110_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PanelInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1110_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PanelInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1110_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PanelInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1110_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PanelInfo::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("PanelInfo", 892, G__RAT_Dict_1110_0_19, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("PanelInfo", 892, G__RAT_Dict_1110_0_20, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::PanelInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PanelInfo", 1018, G__RAT_Dict_1110_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1110_0_22, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::PanelInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLChanHWStatus(void) {
   /* RAT::DU::ChanHWStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus));
   G__memfunc_setup("ChanHWStatus",1181,G__RAT_Dict_1116_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1116_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEnabled",871,G__RAT_Dict_1116_0_3, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWord",700,G__RAT_Dict_1116_0_4, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThreshold",1229,G__RAT_Dict_1116_0_5, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThresholdZero",1645,G__RAT_Dict_1116_0_6, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThresholdAboveNoise",2232,G__RAT_Dict_1116_0_7, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMBID",572,G__RAT_Dict_1116_0_8, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDBID",563,G__RAT_Dict_1116_0_9, 105, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTubeOnline",1201,G__RAT_Dict_1116_0_10, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTubeAtHighVoltage",1875,G__RAT_Dict_1116_0_11, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsChannelOnline",1498,G__RAT_Dict_1116_0_12, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDAQEnabled",1085,G__RAT_Dict_1116_0_13, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNHit100Enabled",1387,G__RAT_Dict_1116_0_14, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNHit20Enabled",1340,G__RAT_Dict_1116_0_15, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEsumLowEnabled",1587,G__RAT_Dict_1116_0_16, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEsumHighEnabled",1665,G__RAT_Dict_1116_0_17, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSequencerEnabled",1810,G__RAT_Dict_1116_0_18, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsECAChannelActive",1690,G__RAT_Dict_1116_0_19, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 10 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1116_0_20, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::ChanHWStatus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1116_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanHWStatus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1116_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::ChanHWStatus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1116_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::ChanHWStatus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1116_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1116_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanHWStatus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1116_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::ChanHWStatus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1116_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::ChanHWStatus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1116_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::ChanHWStatus::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ChanHWStatus", 1181, G__RAT_Dict_1116_0_32, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ChanHWStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ChanHWStatus", 1307, G__RAT_Dict_1116_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1116_0_34, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ChanHWStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLPMTCalStatus(void) {
   /* RAT::DU::PMTCalStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus));
   G__memfunc_setup("PMTCalStatus",1157,G__RAT_Dict_1123_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1123_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellStatus",1316,G__RAT_Dict_1123_0_3, 104, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChannelStatus",1629,G__RAT_Dict_1123_0_4, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - lcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FlagHits",786,G__RAT_Dict_1123_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillFlag",769,G__RAT_Dict_1123_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<int,allocator<int> >' 'vector<int>' 11 - flags", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1123_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::PMTCalStatus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1123_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTCalStatus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1123_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::PMTCalStatus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1123_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::PMTCalStatus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1123_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1123_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTCalStatus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1123_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PMTCalStatus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1123_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::PMTCalStatus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1123_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::PMTCalStatus::DeclFileLine) ), 0);
   G__memfunc_setup("GetChanHWStatus",1469,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus), -1, 1, 0, 3, 4, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChanSWStatus",1480,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus), -1, 1, 0, 3, 4, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitStatus<RAT::DS::PMTCal>",2474,G__RAT_Dict_1123_0_21, 104, -1, -1, 0, 1, 1, 1, 8, "u 'RAT::DS::PMTCal' - 11 - pmthit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitStatus<RAT::FitterPMT>",2557,G__RAT_Dict_1123_0_22, 104, -1, -1, 0, 1, 1, 1, 8, "u 'RAT::FitterPMT' - 11 - pmthit", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("PMTCalStatus", 1157, G__RAT_Dict_1123_0_23, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::PMTCalStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PMTCalStatus", 1283, G__RAT_Dict_1123_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1123_0_25, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::PMTCalStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLReactorNuOsc(void) {
   /* RAT::DU::ReactorNuOsc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1125_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReactorOsc",1013,G__RAT_Dict_1125_0_2, 103, -1, -1, 0, 2, 1, 1, 0, 
"d - - 10 - nuKE u 'string' - 0 - coreData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OscProbability",1446,G__RAT_Dict_1125_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 11 - energy d - - 11 - baseline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sample",610,G__RAT_Dict_1125_0_4, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic default constructor
   G__memfunc_setup("ReactorNuOsc", 1208, G__RAT_Dict_1125_0_5, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ReactorNuOsc", 1208, G__RAT_Dict_1125_0_6, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ReactorNuOsc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ReactorNuOsc", 1334, G__RAT_Dict_1125_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1125_0_8, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ReactorNuOsc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLShadowingCalculator(void) {
   /* RAT::DU::ShadowingCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1126_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForAVHDRopeShadowing",2402,G__RAT_Dict_1126_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForSupportRopeShadowing",2876,G__RAT_Dict_1126_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForBellyPlateShadowing",2711,G__RAT_Dict_1126_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForNCDAnchorShadowing",2521,G__RAT_Dict_1126_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForAVPipeShadowing",2254,G__RAT_Dict_1126_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForNeckBossShadowing",2497,G__RAT_Dict_1126_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForShadowing",1705,G__RAT_Dict_1126_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'RAT::DU::LightPathCalculator' - 1 - lPath", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVHDRopeShadowFlag",1977,G__RAT_Dict_1126_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBellyPlateShadowFlag",2286,G__RAT_Dict_1126_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCDAnchorShadowFlag",2096,G__RAT_Dict_1126_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSupportRopeShadowFlag",2451,G__RAT_Dict_1126_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAVPipeShadowFlag",1829,G__RAT_Dict_1126_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeckBossShadowFlag",2072,G__RAT_Dict_1126_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShadowFlag",1280,G__RAT_Dict_1126_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAllGeometryTolerances",2465,G__RAT_Dict_1126_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - geoTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAVHDRopeTolerance",1922,G__RAT_Dict_1126_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - avhdTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSupportRopeTolerance",2396,G__RAT_Dict_1126_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - suppTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBellyPlateTolerance",2231,G__RAT_Dict_1126_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - bpTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNCDAnchorTolerance",2041,G__RAT_Dict_1126_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - ncdTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAVPipeTolerance",1774,G__RAT_Dict_1126_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - avPipeTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNeckBossTolerance",2017,G__RAT_Dict_1126_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - neckBossTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadAVHDRopeInfo",1477,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadSupportRopeInfo",1951,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadBellyPlateInfo",1786,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadNCDAnchorInfo",1596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadAVPipeInfo",1329,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadNeckBossInfo",1572,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillXYZPositions",1626,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"u 'vector<TVector3,allocator<TVector3> >' 'vector<TVector3>' 1 - positions u 'string' - 11 - tableName "
"u 'string' - 11 - indexName u 'string' - 11 '\"x\"' xField "
"u 'string' - 11 '\"y\"' yField u 'string' - 11 '\"z\"' zField", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VectorToSphereEdge",1810,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - startPos u 'TVector3' - 11 - startDir "
"d - 'Double_t' 10 - radiusFromCentre g - 'Bool_t' 10 - outside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VectorToCylinderEdge",2021,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 4, 1, 4, 0, 
"u 'TVector3' - 11 - startPos u 'TVector3' - 11 - startDir "
"u 'TVector3' - 11 - cylinderBaseOrigin d - 'Double_t' 10 - cylinderRadius", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClosestAngle",1220,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'TVector3' - 11 - eventPos d - 'Double_t' 10 - edgeRadius", (char*)NULL, (void*) NULL, 0);
   // automatic default constructor
   G__memfunc_setup("ShadowingCalculator", 1966, G__RAT_Dict_1126_0_33, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ShadowingCalculator", 1966, G__RAT_Dict_1126_0_34, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ShadowingCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ShadowingCalculator", 2092, G__RAT_Dict_1126_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1126_0_36, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ShadowingCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLSegmentor(void) {
   /* RAT::DU::Segmentor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor));
   G__memfunc_setup("Segmentor",948,G__RAT_Dict_1127_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1127_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumberOfDivisions",2050,G__RAT_Dict_1127_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 10 - numberOfDivisions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfDivisions",2038,G__RAT_Dict_1127_0_4, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPatternZaxis",1561,G__RAT_Dict_1127_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - patternZaxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPatternZaxis",1561,G__RAT_Dict_1127_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVector3' - 11 - patternZaxis i - - 10 - numberOfDivisions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPatternOrigin",1650,G__RAT_Dict_1127_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVector3' - 11 - patternOrigin u 'TVector3' - 11 - patternZaxis "
"i - - 10 - numberOfDivisions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPatternOrigin",1638,G__RAT_Dict_1127_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPatternZaxis",1549,G__RAT_Dict_1127_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPatternXaxis",1547,G__RAT_Dict_1127_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPatternYaxis",1548,G__RAT_Dict_1127_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSegmentIDs",1267,G__RAT_Dict_1127_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSegmentPopulations",2193,G__RAT_Dict_1127_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1127_0_14, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::Segmentor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1127_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Segmentor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1127_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::Segmentor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1127_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Segmentor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1127_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1127_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Segmentor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1127_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Segmentor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1127_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Segmentor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1127_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Segmentor::DeclFileLine) ), 0);
   G__memfunc_setup("Calculate",910,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Segmentor", 948, G__RAT_Dict_1127_0_27, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::Segmentor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Segmentor", 1074, G__RAT_Dict_1127_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1127_0_29, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::Segmentor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLSOCReader(void) {
   /* RAT::DU::SOCReader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader));
   G__memfunc_setup("SOCReader",824,G__RAT_Dict_1128_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - filename g - - 10 'true' useMeta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SOCReader",824,G__RAT_Dict_1128_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader), -1, 0, 2, 1, 1, 0, 
"u 'vector<string,allocator<string> >' 'vector<std::string>' 11 - filenames g - - 10 'true' useMeta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1128_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__RAT_Dict_1128_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOC",517,G__RAT_Dict_1128_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLSOC), -1, 1, 1, 1, 1, 1, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSOCCount",1038,G__RAT_Dict_1128_0_6, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRun",597,G__RAT_Dict_1128_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunByRunID",1234,G__RAT_Dict_1128_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 1, 1, 1, 1, "k - 'size_t' 10 - runID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunByIndex",1288,G__RAT_Dict_1128_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 1, 1, 1, 1, 1, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRunCount",1118,G__RAT_Dict_1128_0_10, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1128_0_11, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::SOCReader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1128_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::SOCReader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1128_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::SOCReader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1128_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::SOCReader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1128_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1128_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::SOCReader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1128_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::SOCReader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1128_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::SOCReader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1128_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::SOCReader::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SOCReader", 824, G__RAT_Dict_1128_0_23, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::SOCReader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SOCReader", 950, G__RAT_Dict_1128_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1128_0_25, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::SOCReader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLReconCorrector(void) {
   /* RAT::DU::ReconCorrector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector));
   G__memfunc_setup("Get",288,G__RAT_Dict_1129_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (RAT::DU::ReconCorrector* (*)())(&RAT::DU::ReconCorrector::Get) ), 0);
   G__memfunc_setup("ReconCorrector",1450,G__RAT_Dict_1129_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1129_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__RAT_Dict_1129_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CorrectRSPTables",1570,G__RAT_Dict_1129_0_5, 100, -1, -1, 0, 5, 1, 1, 8, 
"d - - 10 - energy u 'vector<double,allocator<double> >' 'vector<double>' 11 - inTableOld "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - outTableOld u 'vector<double,allocator<double> >' 'vector<double>' 11 - inTableNew "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - outTableNew", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CorrectEnergyRSP",1585,G__RAT_Dict_1129_0_6, 100, -1, -1, 0, 2, 1, 1, 8, 
"d - - 0 - energy i - - 0 '1' version", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Interpolate1D",1276,G__RAT_Dict_1129_0_7, 100, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - inValue u 'vector<double,allocator<double> >' 'vector<double>' 11 - inTable "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - outTable", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ReconCorrector", 1450, G__RAT_Dict_1129_0_8, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ReconCorrector' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ReconCorrector", 1576, G__RAT_Dict_1129_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1129_0_10, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ReconCorrector' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLReconCalibrator(void) {
   /* RAT::DU::ReconCalibrator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator));
   G__memfunc_setup("Get",288,G__RAT_Dict_1130_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (RAT::DU::ReconCalibrator* (*)())(&RAT::DU::ReconCalibrator::Get) ), 0);
   G__memfunc_setup("ReconCalibrator",1530,G__RAT_Dict_1130_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1130_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__RAT_Dict_1130_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalibrateEnergyRSP",1766,G__RAT_Dict_1130_0_5, 100, -1, -1, 0, 6, 1, 1, 8, 
"g - - 0 - isData d - - 0 - energy "
"d - - 0 - rho d - - 0 - z "
"d - - 0 '0' UdotR i - - 0 '1' version", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ReconCalibrator", 1530, G__RAT_Dict_1130_0_6, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::ReconCalibrator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ReconCalibrator", 1656, G__RAT_Dict_1130_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1130_0_8, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::ReconCalibrator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLFitterPMT(void) {
   /* RAT::FitterPMT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT));
   G__memfunc_setup("FitterPMT",863,G__RAT_Dict_1131_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FitterPMT",863,G__RAT_Dict_1131_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::PMTCal' - 11 - pmtCal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FitterPMT",863,G__RAT_Dict_1131_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT), -1, 0, 1, 1, 1, 0, "u 'RAT::DS::SOCPMT' - 11 - socPMT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__RAT_Dict_1131_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCCCC",556,G__RAT_Dict_1131_0_5, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTime",687,G__RAT_Dict_1131_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimeError",1209,G__RAT_Dict_1131_0_7, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHL",517,G__RAT_Dict_1131_0_8, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHLError",1039,G__RAT_Dict_1131_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHS",524,G__RAT_Dict_1131_0_10, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQHSError",1046,G__RAT_Dict_1131_0_11, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQLX",533,G__RAT_Dict_1131_0_12, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQLXError",1055,G__RAT_Dict_1131_0_13, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__RAT_Dict_1131_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLBitMask), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCrossTalkFlag",1584,G__RAT_Dict_1131_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FitterPMT", 863, G__RAT_Dict_1131_0_16, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT), -1, 0, 1, 1, 1, 0, "u 'RAT::FitterPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FitterPMT", 989, G__RAT_Dict_1131_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1131_0_18, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLFitterPMT), -1, 1, 1, 1, 1, 0, "u 'RAT::FitterPMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLTimeResidualCalculator(void) {
   /* RAT::DU::TimeResidualCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator));
   G__memfunc_setup("TimeResidualCalculator",2258,G__RAT_Dict_1132_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1132_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcTimeResidual",1595,G__RAT_Dict_1132_0_3, 100, -1, -1, 0, 7, 1, 1, 0, 
"u 'RAT::DS::PMTCal' - 11 - pmtCal u 'TVector3' - 11 - fitPos "
"d - - 10 - fitTime g - 'Bool_t' 10 'false' useGroup "
"d - 'Double_t' 10 '3.103125*1e-6' photonEnergy g - 'Bool_t' 10 'false' useBucket "
"d - 'Double_t' 10 '0.0' localityVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcTimeResidual",1595,G__RAT_Dict_1132_0_4, 100, -1, -1, 0, 7, 1, 1, 0, 
"u 'RAT::FitterPMT' - 11 - pmtFitter u 'TVector3' - 11 - fitPos "
"d - - 10 - fitTime g - 'Bool_t' 10 'false' useGroup "
"d - 'Double_t' 10 '3.103125*1e-6' photonEnergy g - 'Bool_t' 10 'false' useBucket "
"d - 'Double_t' 10 '0.0' localityVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcTimeResidual",1595,G__RAT_Dict_1132_0_5, 100, -1, -1, 0, 8, 1, 1, 0, 
"h - 'UInt_t' 10 - pmtID d - - 10 - pmtTime "
"u 'TVector3' - 11 - fitPos d - - 10 - fitTime "
"g - 'Bool_t' 10 'false' useGroup d - 'Double_t' 10 '3.103125*1e-6' photonEnergy "
"g - 'Bool_t' 10 'false' useBucket d - 'Double_t' 10 '0.0' localityVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1132_0_6, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::TimeResidualCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1132_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TimeResidualCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1132_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::TimeResidualCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1132_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::TimeResidualCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1132_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1132_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TimeResidualCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1132_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::TimeResidualCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1132_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::TimeResidualCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1132_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::TimeResidualCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TimeResidualCalculator", 2258, G__RAT_Dict_1132_0_18, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::TimeResidualCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TimeResidualCalculator", 2384, G__RAT_Dict_1132_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1132_0_20, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::TimeResidualCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLUtility(void) {
   /* RAT::DU::Utility */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility));
   G__memfunc_setup("Get",288,G__RAT_Dict_1133_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (RAT::DU::Utility* (*)())(&RAT::DU::Utility::Get) ), 0);
   G__memfunc_setup("LoadDBAndBeginRun",1587,G__RAT_Dict_1133_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Utility::LoadDBAndBeginRun) ), 0);
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1133_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMTInfo",925,G__RAT_Dict_1133_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPanelInfo",1180,G__RAT_Dict_1133_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChanHWStatus",1469,G__RAT_Dict_1133_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPMTCalStatus",1445,G__RAT_Dict_1133_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReactorNuOsc",1496,G__RAT_Dict_1133_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSegmentor",1236,G__RAT_Dict_1133_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLightPathCalculator",2223,G__RAT_Dict_1133_0_10, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGroupVelocity",1660,G__RAT_Dict_1133_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEffectiveVelocity",2048,G__RAT_Dict_1133_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataCleaningBits",1869,G__RAT_Dict_1133_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataQualityBits",1813,G__RAT_Dict_1133_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChanSWStatus",1480,G__RAT_Dict_1133_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigBits",1096,G__RAT_Dict_1133_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShadowingCalculator",2254,G__RAT_Dict_1133_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReconCorrector",1738,G__RAT_Dict_1133_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReconCalibrator",1818,G__RAT_Dict_1133_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTimeResidualCalculator",2546,G__RAT_Dict_1133_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Utility",756,G__RAT_Dict_1133_0_21, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility), -1, 0, 1, 1, 1, 0, "U 'TRootIOCtor' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1133_0_22, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::Utility::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1133_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Utility::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1133_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::Utility::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1133_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Utility::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1133_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1133_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Utility::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1133_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Utility::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1133_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Utility::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1133_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Utility::DeclFileLine) ), 0);
   G__memfunc_setup("Utility",756,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Utility",756,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLUtility), -1, 0, 1, 1, 4, 0, "u 'RAT::DU::Utility' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'RAT::DU::Utility' - 1 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Utility", 882, G__RAT_Dict_1133_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLTrackNode(void) {
   /* RAT::TrackNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode));
   G__memfunc_setup("TrackNode",891,G__RAT_Dict_1135_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTrackStart",1215,G__RAT_Dict_1135_0_2, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTrackStart",1327,G__RAT_Dict_1135_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsTrackEnd",968,G__RAT_Dict_1135_0_4, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTrackID",930,G__RAT_Dict_1135_0_5, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTrackID",942,G__RAT_Dict_1135_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - _trackID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStepID",841,G__RAT_Dict_1135_0_7, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStepID",853,G__RAT_Dict_1135_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - _stepID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPDGCode",886,G__RAT_Dict_1135_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPDGCode",898,G__RAT_Dict_1135_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - _pdgcode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParticleName",1493,G__RAT_Dict_1135_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParticleName",1505,G__RAT_Dict_1135_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - _particleName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrev",701,G__RAT_Dict_1135_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPrev",713,G__RAT_Dict_1135_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 0 - _prev", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNext",703,G__RAT_Dict_1135_0_15, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNext",715,G__RAT_Dict_1135_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 0 - _next", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddNext",680,G__RAT_Dict_1135_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddChild",749,G__RAT_Dict_1135_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1135_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 1, 1, 1, 0, "u 'RAT::DS::MCTrackStep' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__RAT_Dict_1135_0_20, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::TrackNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1135_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::TrackNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1135_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::TrackNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1135_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::TrackNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1135_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1135_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::TrackNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1135_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::TrackNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1135_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::TrackNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1135_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::TrackNode::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TrackNode", 891, G__RAT_Dict_1135_0_32, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "u 'RAT::TrackNode' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrackNode", 1017, G__RAT_Dict_1135_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1135_0_34, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 1, 1, 1, 0, "u 'RAT::TrackNode' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR(void) {
   /* vector<RAT::TrackNode*,allocator<RAT::TrackNode*> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_1137_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_1137_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_1137_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_1137_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_1137_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_1137_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_1137_0_7, 107, -1, G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_1137_0_8, 107, -1, G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1137_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1137_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - sz U 'RAT::TrackNode' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_1137_0_11, 107, -1, G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_1137_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1137_0_13, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1137_0_14, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >",4500,G__RAT_Dict_1137_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >",4500,G__RAT_Dict_1137_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n U 'RAT::TrackNode' - 41 '(RAT::TrackNode*)()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >",4500,G__RAT_Dict_1137_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >",4500,G__RAT_Dict_1137_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator' 10 - first u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1137_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_1137_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_1137_0_21, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_1137_0_22, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_1137_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_1137_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1137_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - position U 'RAT::TrackNode' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1137_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - position u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator' 10 - first "
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1137_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - position k - 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::size_type' 0 - n "
"U 'RAT::TrackNode' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_1137_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1137_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1137_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - first u 'vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1137_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >", 4626, G__RAT_Dict_1137_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLTrackCursor(void) {
   /* RAT::TrackCursor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor));
   G__memfunc_setup("TrackCursor",1139,G__RAT_Dict_1142_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor), -1, 0, 2, 1, 1, 0, 
"U 'RAT::TrackNode' - 0 - node g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVerbose",1014,G__RAT_Dict_1142_0_2, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVerbose",1026,G__RAT_Dict_1142_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackStart",1027,G__RAT_Dict_1142_0_4, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Prev",413,G__RAT_Dict_1142_0_5, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Here",388,G__RAT_Dict_1142_0_6, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__RAT_Dict_1142_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackEnd",780,G__RAT_Dict_1142_0_8, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StepCount",933,G__RAT_Dict_1142_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,G__RAT_Dict_1142_0_10, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChildCount",1005,G__RAT_Dict_1142_0_11, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Child",484,G__RAT_Dict_1142_0_12, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 8, "k - 'size_t' 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackChildCount",1506,G__RAT_Dict_1142_0_13, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackChild",985,G__RAT_Dict_1142_0_14, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 8, "k - 'size_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parent",618,G__RAT_Dict_1142_0_15, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackLength",1111,G__RAT_Dict_1142_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTrackStart",1215,G__RAT_Dict_1142_0_17, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTrackEnd",968,G__RAT_Dict_1142_0_18, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Go",182,G__RAT_Dict_1142_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::TrackNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoTrackStart",1209,G__RAT_Dict_1142_0_20, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoPrev",595,G__RAT_Dict_1142_0_21, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoNext",597,G__RAT_Dict_1142_0_22, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoTrackEnd",962,G__RAT_Dict_1142_0_23, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoStep",594,G__RAT_Dict_1142_0_24, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoChild",666,G__RAT_Dict_1142_0_25, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "i - - 0 '0' i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoTrackChild",1167,G__RAT_Dict_1142_0_26, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoParent",800,G__RAT_Dict_1142_0_27, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", "Go to the step in the parent particle where", (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__RAT_Dict_1142_0_28, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintTrack",1026,G__RAT_Dict_1142_0_29, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintTrackIDs",1282,G__RAT_Dict_1142_0_30, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 0, "U 'RAT::TrackNode' - 0 - node", (char*)NULL, (void*) G__func2void( (string (*)(RAT::TrackNode*))(&RAT::TrackCursor::PrintTrackIDs) ), 0);
   G__memfunc_setup("Print",525,G__RAT_Dict_1142_0_31, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 0, "U 'RAT::TrackNode' - 0 - node", (char*)NULL, (void*) G__func2void( (string (*)(RAT::TrackNode*))(&RAT::TrackCursor::Print) ), 0);
   G__memfunc_setup("PrintTrack",1026,G__RAT_Dict_1142_0_32, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 0, "U 'RAT::TrackNode' - 0 - node", (char*)NULL, (void*) G__func2void( (string (*)(RAT::TrackNode*))(&RAT::TrackCursor::PrintTrack) ), 0);
   G__memfunc_setup("FindNextTrack",1301,G__RAT_Dict_1142_0_33, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextTrackNoDescend",2184,G__RAT_Dict_1142_0_34, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextTrack",1301,G__RAT_Dict_1142_0_35, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "U 'RAT::TrackTest' - 0 - predicate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextParticle",1620,G__RAT_Dict_1142_0_36, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - particleName", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TrackCursor", 1139, G__RAT_Dict_1142_0_37, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor), -1, 0, 1, 1, 1, 0, "u 'RAT::TrackCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrackCursor", 1265, G__RAT_Dict_1142_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1142_0_39, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor), -1, 1, 1, 1, 1, 0, "u 'RAT::TrackCursor' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLTrackNav(void) {
   /* RAT::TrackNav */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav));
   G__memfunc_setup("TrackNav",794,G__RAT_Dict_1144_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav), -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::Entry' - 10 - ds g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrackNav",794,G__RAT_Dict_1144_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav), -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::MC' - 0 - mc g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Load",384,G__RAT_Dict_1144_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::MC' - 10 - mc g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__RAT_Dict_1144_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Head",370,G__RAT_Dict_1144_0_5, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cursor",638,G__RAT_Dict_1144_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackCursor), -1, 0, 1, 1, 1, 0, "g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindID",526,G__RAT_Dict_1144_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 1, 1, 1, 0, "i - - 0 - trackID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindParticle",1205,G__RAT_Dict_1144_0_8, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - particleName g - - 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TrackNav", 794, G__RAT_Dict_1144_0_9, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav), -1, 0, 1, 1, 1, 0, "u 'RAT::TrackNav' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrackNav", 920, G__RAT_Dict_1144_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1144_0_11, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNav), -1, 1, 1, 1, 1, 0, "u 'RAT::TrackNav' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDBCommandLoader(void) {
   /* RAT::DBCommandLoader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader));
   G__memfunc_setup("LoadCommands",1202,G__RAT_Dict_1167_0_1, 121, -1, -1, 0, 1, 3, 1, 0, "u 'RAT::DS::Meta' - 11 - meta", (char*)NULL, (void*) G__func2void( (void (*)(const RAT::DS::Meta&))(&RAT::DBCommandLoader::LoadCommands) ), 0);
   G__memfunc_setup("LoadCommand",1087,G__RAT_Dict_1167_0_2, 121, -1, -1, 0, 2, 3, 1, 0, 
"u 'string' - 11 - tableField u 'string' - 11 - value", (char*)NULL, (void*) G__func2void( (void (*)(const string&, const string&))(&RAT::DBCommandLoader::LoadCommand) ), 0);
   G__memfunc_setup("LoadFile",768,G__RAT_Dict_1167_0_3, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - contents", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&RAT::DBCommandLoader::LoadFile) ), 0);
   // automatic default constructor
   G__memfunc_setup("DBCommandLoader", 1436, G__RAT_Dict_1167_0_4, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DBCommandLoader", 1436, G__RAT_Dict_1167_0_5, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader), -1, 0, 1, 1, 1, 0, "u 'RAT::DBCommandLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DBCommandLoader", 1562, G__RAT_Dict_1167_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1167_0_7, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBCommandLoader), -1, 1, 1, 1, 1, 0, "u 'RAT::DBCommandLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDBTextLoader(void) {
   /* RAT::DBTextLoader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader));
   G__memfunc_setup("parse",539,G__RAT_Dict_1195_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), G__defined_typename("vector<RAT::DBTable*>"), 0, 1, 3, 1, 0, "u 'string' - 0 - filename", (char*)NULL, (void*) G__func2void( (vector<RAT::DBTable*> (*)(string))(&RAT::DBTextLoader::parse) ), 0);
   // automatic default constructor
   G__memfunc_setup("DBTextLoader", 1154, G__RAT_Dict_1195_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DBTextLoader", 1154, G__RAT_Dict_1195_0_3, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader), -1, 0, 1, 1, 1, 0, "u 'RAT::DBTextLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DBTextLoader", 1280, G__RAT_Dict_1195_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1195_0_5, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTextLoader), -1, 1, 1, 1, 1, 0, "u 'RAT::DBTextLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDBJsonLoader(void) {
   /* RAT::DBJsonLoader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader));
   G__memfunc_setup("parse",539,G__RAT_Dict_1196_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), G__defined_typename("vector<RAT::DBTable*>"), 0, 1, 3, 1, 0, "u 'string' - 11 - filename", (char*)NULL, (void*) G__func2void( (vector<RAT::DBTable*> (*)(const string&))(&RAT::DBJsonLoader::parse) ), 0);
   G__memfunc_setup("parseString",1170,G__RAT_Dict_1196_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR), G__defined_typename("vector<RAT::DBTable*>"), 0, 1, 3, 1, 0, "u 'string' - 11 - data", (char*)NULL, (void*) G__func2void( (vector<RAT::DBTable*> (*)(const string&))(&RAT::DBJsonLoader::parseString) ), 0);
   G__memfunc_setup("convertTable",1257,G__RAT_Dict_1196_0_3, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 0, 1, 3, 1, 0, "u 'json::Value' - 11 - jsonDoc", (char*)NULL, (void*) G__func2void( (RAT::DBTable* (*)(const json::Value&))(&RAT::DBJsonLoader::convertTable) ), 0);
   // automatic default constructor
   G__memfunc_setup("DBJsonLoader", 1143, G__RAT_Dict_1196_0_4, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("DBJsonLoader", 1143, G__RAT_Dict_1196_0_5, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader), -1, 0, 1, 1, 1, 0, "u 'RAT::DBJsonLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DBJsonLoader", 1269, G__RAT_Dict_1196_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1196_0_7, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBJsonLoader), -1, 1, 1, 1, 1, 0, "u 'RAT::DBJsonLoader' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLHTTPDownloader(void) {
   /* RAT::HTTPDownloader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLHTTPDownloader));
   G__memfunc_setup("HTTPDownloader",1359,G__RAT_Dict_1197_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLHTTPDownloader), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Disconnect",1034,G__RAT_Dict_1197_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fetch",490,G__RAT_Dict_1197_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - url", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurlOpts",1128,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HTTPDownloader", 1485, G__RAT_Dict_1197_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLMetaInformation(void) {
   /* RAT::MetaInformation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation));
   G__memfunc_setup("Get",288,G__RAT_Dict_1198_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (RAT::MetaInformation* (*)())(&RAT::MetaInformation::Get) ), 0);
   G__memfunc_setup("Initialise",1035,G__RAT_Dict_1198_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialise",1035,G__RAT_Dict_1198_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RAT::DS::Meta' - 40 - meta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Finalise",811,G__RAT_Dict_1198_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::MetaHelper' - 11 - helper", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOverrideCommand",1800,G__RAT_Dict_1198_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - tableField u 'string' - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLoadCommand",1352,G__RAT_Dict_1198_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDSMeta",830,G__RAT_Dict_1198_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLMeta), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentPass",1434,G__RAT_Dict_1198_0_8, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MetaInformation",1549,G__RAT_Dict_1198_0_9, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation), -1, 0, 1, 1, 1, 0, "U 'TRootIOCtor' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadDirectory",1333,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'string' - 11 - directory", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadFile",768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'string' - 11 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MetaInformation",1549,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MetaInformation", 1549, G__RAT_Dict_1198_0_13, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation), -1, 0, 1, 1, 1, 0, "u 'RAT::MetaInformation' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MetaInformation", 1675, G__RAT_Dict_1198_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1198_0_15, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLMetaInformation), -1, 1, 1, 1, 1, 0, "u 'RAT::MetaInformation' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPmtEventRecord(void) {
   /* PmtEventRecord */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord));
   // automatic default constructor
   G__memfunc_setup("PmtEventRecord", 1426, G__RAT_Dict_1199_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("PmtEventRecord", 1426, G__RAT_Dict_1199_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 0, 1, 1, 1, 0, "u 'PmtEventRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PmtEventRecord", 1552, G__RAT_Dict_1199_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1199_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 1, 1, 1, 1, 0, "u 'PmtEventRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRunRecord(void) {
   /* RunRecord */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RunRecord));
   // automatic default constructor
   G__memfunc_setup("RunRecord", 916, G__RAT_Dict_1200_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RunRecord), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("RunRecord", 916, G__RAT_Dict_1200_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RunRecord), -1, 0, 1, 1, 1, 0, "u 'RunRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~RunRecord", 1042, G__RAT_Dict_1200_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1200_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RunRecord), -1, 1, 1, 1, 1, 0, "u 'RunRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTriggerInfo(void) {
   /* TriggerInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo));
   // automatic default constructor
   G__memfunc_setup("TriggerInfo", 1120, G__RAT_Dict_1201_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TriggerInfo", 1120, G__RAT_Dict_1201_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo), -1, 0, 1, 1, 1, 0, "u 'TriggerInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TriggerInfo", 1246, G__RAT_Dict_1201_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1201_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo), -1, 1, 1, 1, 1, 0, "u 'TriggerInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncEpedRecord(void) {
   /* EpedRecord */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord));
   // automatic default constructor
   G__memfunc_setup("EpedRecord", 989, G__RAT_Dict_1202_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("EpedRecord", 989, G__RAT_Dict_1202_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord), -1, 0, 1, 1, 1, 0, "u 'EpedRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EpedRecord", 1115, G__RAT_Dict_1202_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1202_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord), -1, 1, 1, 1, 1, 0, "u 'EpedRecord' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdab(void) {
   /* ratzdab */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdab));
   G__memfunc_setup("get_pdg_to_snoman_map",2212,G__RAT_Dict_1203_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR), G__defined_typename("map<int,int>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (map<int,int> (*)())(&ratzdab::get_pdg_to_snoman_map) ), 0);
   G__memfunc_setup("get_pdg_to_mass_map",1996,G__RAT_Dict_1203_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR), G__defined_typename("map<int,float>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (map<int,float> (*)())(&ratzdab::get_pdg_to_mass_map) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdabcLcLunpack(void) {
   /* ratzdab::unpack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunpack));
   G__memfunc_setup("event",546,G__RAT_Dict_1204_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLEntry), -1, 0, 1, 1, 1, 0, "U 'PmtEventRecord' - 40 - o", (char*)NULL, (void*) G__func2void( (RAT::DS::Entry* (*)(PmtEventRecord *const))(&ratzdab::unpack::event) ), 0);
   G__memfunc_setup("rhdr",432,G__RAT_Dict_1204_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLRun), -1, 0, 1, 1, 1, 0, "U 'RunRecord' - 40 - o", (char*)NULL, (void*) G__func2void( (RAT::DS::Run* (*)(RunRecord *const))(&ratzdab::unpack::rhdr) ), 0);
   G__memfunc_setup("trig",438,G__RAT_Dict_1204_0_3, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader), -1, 0, 1, 1, 1, 0, "U 'TriggerInfo' - 40 - o", (char*)NULL, (void*) G__func2void( (RAT::DS::TrigHeader* (*)(TriggerInfo *const))(&ratzdab::unpack::trig) ), 0);
   G__memfunc_setup("eped",414,G__RAT_Dict_1204_0_4, 85, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLECAHeader), -1, 0, 1, 1, 1, 0, "U 'EpedRecord' - 40 - o", (char*)NULL, (void*) G__func2void( (RAT::DS::ECAHeader* (*)(EpedRecord *const))(&ratzdab::unpack::eped) ), 0);
   G__memfunc_setup("caen",407,G__RAT_Dict_1204_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLDigitiser), -1, 0, 1, 1, 1, 0, "H - 'uint32_t' 40 - p", (char*)NULL, (void*) G__func2void( (RAT::DS::Digitiser (*)(uint32_t *const))(&ratzdab::unpack::caen) ), 0);
   G__memfunc_setup("pmt",337,G__RAT_Dict_1204_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR), G__defined_typename("RAT::DS::PMTUncal"), 0, 2, 1, 1, 0, 
"H - 'uint32_t' 40 - p i - - 10 - lcn", (char*)NULL, (void*) G__func2void( (RAT::DS::PMTUncal (*)(uint32_t *const, const int))(&ratzdab::unpack::pmt) ), 0);
   G__memfunc_setup("tubii",541,G__RAT_Dict_1204_0_7, 104, -1, G__defined_typename("uint32_t"), 0, 1, 1, 1, 0, "H - 'uint32_t' 40 - p", (char*)NULL, (void*) G__func2void( (uint32_t (*)(uint32_t *const))(&ratzdab::unpack::tubii) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdabcLcLpack(void) {
   /* ratzdab::pack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLpack));
   G__memfunc_setup("event",546,G__RAT_Dict_1205_0_1, 85, G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::Entry' - 0 - o i - - 0 '0' ev_id", (char*)NULL, (void*) G__func2void( (PmtEventRecord* (*)(RAT::DS::Entry*, int))(&ratzdab::pack::event) ), 0);
   G__memfunc_setup("rhdr",432,G__RAT_Dict_1205_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_RunRecord), -1, 0, 1, 1, 1, 0, "U 'RAT::DS::Run' - 40 - o", (char*)NULL, (void*) G__func2void( (RunRecord* (*)(RAT::DS::Run *const))(&ratzdab::pack::rhdr) ), 0);
   G__memfunc_setup("trig",438,G__RAT_Dict_1205_0_3, 85, G__get_linked_tagnum(&G__RAT_DictLN_TriggerInfo), -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::TrigHeader' - 40 - o h - 'uint32_t' 10 - gtid", (char*)NULL, (void*) G__func2void( (TriggerInfo* (*)(RAT::DS::TrigHeader *const, const uint32_t))(&ratzdab::pack::trig) ), 0);
   G__memfunc_setup("eped",414,G__RAT_Dict_1205_0_4, 85, G__get_linked_tagnum(&G__RAT_DictLN_EpedRecord), -1, 0, 2, 1, 1, 0, 
"U 'RAT::DS::ECAHeader' - 40 - o h - 'uint32_t' 10 - gtid", (char*)NULL, (void*) G__func2void( (EpedRecord* (*)(RAT::DS::ECAHeader *const, const uint32_t))(&ratzdab::pack::eped) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdabcLcLunknown_record_error(void) {
   /* ratzdab::unknown_record_error */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error));
   G__memfunc_setup("what",436,G__RAT_Dict_1213_0_1, 67, -1, -1, 0, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 1);
   // automatic default constructor
   G__memfunc_setup("unknown_record_error", 2167, G__RAT_Dict_1213_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("unknown_record_error", 2167, G__RAT_Dict_1213_0_3, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLunknown_record_error), -1, 0, 1, 1, 1, 0, "u 'ratzdab::unknown_record_error' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~unknown_record_error", 2293, G__RAT_Dict_1213_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPZdabFile(void) {
   /* PZdabFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile));
   G__memfunc_setup("PZdabFile",849,G__RAT_Dict_1214_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__RAT_Dict_1214_0_2, 105, -1, -1, 0, 1, 1, 1, 0, "E - - 0 - inFile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Free",386,G__RAT_Dict_1214_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextRecord",1022,G__RAT_Dict_1214_0_4, 85, G__get_linked_tagnum(&G__RAT_DictLN_nZDAB), G__defined_typename("nZDAB"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextPmt",720,G__RAT_Dict_1214_0_5, 85, G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextBank",795,G__RAT_Dict_1214_0_6, 72, -1, G__defined_typename("uint32_t"), 0, 1, 1, 1, 0, "h - 'uint32_t' 0 - bank_name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPmtRecord",1200,G__RAT_Dict_1214_0_7, 85, G__get_linked_tagnum(&G__RAT_DictLN_PmtEventRecord), -1, 0, 1, 1, 1, 0, "U 'nZDAB' 'nZDAB' 0 - nzdabPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBank",668,G__RAT_Dict_1214_0_8, 72, -1, G__defined_typename("uint32_t"), 0, 2, 3, 1, 0, 
"U 'nZDAB' 'nZDAB' 0 - nzdabPtr h - 'uint32_t' 0 '0' bank_name", (char*)NULL, (void*) G__func2void( (uint32_t* (*)(nZDAB*, uint32_t))(&PZdabFile::GetBank) ), 0);
   G__memfunc_setup("GetSize",699,G__RAT_Dict_1214_0_9, 104, -1, G__defined_typename("uint32_t"), 0, 1, 3, 1, 0, "U 'PmtEventRecord' - 0 - pmtRecord", (char*)NULL, (void*) G__func2void( (uint32_t (*)(PmtEventRecord*))(&PZdabFile::GetSize) ), 0);
   G__memfunc_setup("GetExtendedData",1483,G__RAT_Dict_1214_0_10, 72, -1, G__defined_typename("uint32_t"), 0, 2, 3, 1, 0, 
"U 'PmtEventRecord' - 0 - pmtRecord i - - 0 - subType", (char*)NULL, (void*) G__func2void( (uint32_t* (*)(PmtEventRecord*, int))(&PZdabFile::GetExtendedData) ), 0);
   G__memfunc_setup("GetNcdData",943,G__RAT_Dict_1214_0_11, 72, -1, G__defined_typename("uint32_t"), 0, 1, 3, 1, 0, "U 'PmtEventRecord' - 0 - pmtRecord", (char*)NULL, (void*) G__func2void( (uint32_t* (*)(PmtEventRecord*))(&PZdabFile::GetNcdData) ), 0);
   G__memfunc_setup("DumpHex",699,G__RAT_Dict_1214_0_12, 121, -1, -1, 0, 2, 3, 1, 0, 
"U 'nZDAB' 'nZDAB' 0 - nzdabPtr i - - 0 '16' numToPrint", (char*)NULL, (void*) G__func2void( (void (*)(nZDAB*, int))(&PZdabFile::DumpHex) ), 0);
   G__memfunc_setup("BankName",765,G__RAT_Dict_1214_0_13, 104, -1, G__defined_typename("uint32_t"), 0, 1, 3, 1, 0, "C - - 0 - bank_name_string", (char*)NULL, (void*) G__func2void( (uint32_t (*)(char*))(&PZdabFile::BankName) ), 0);
   G__memfunc_setup("BankNameString",1396,G__RAT_Dict_1214_0_14, 67, -1, -1, 0, 1, 3, 1, 0, "h - 'uint32_t' 0 - bank_name", (char*)NULL, (void*) G__func2void( (char* (*)(uint32_t))(&PZdabFile::BankNameString) ), 0);
   G__memfunc_setup("AddSubField",1047,G__RAT_Dict_1214_0_15, 121, -1, -1, 0, 3, 3, 1, 0, 
"H - 'uint32_t' 2 - io_sub_header_pt i - - 0 - sub_type "
"h - 'uint32_t' 0 - numBytes", (char*)NULL, (void*) G__func2void( (void (*)(uint32_t**, int, uint32_t))(&PZdabFile::AddSubField) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PZdabFile", 849, G__RAT_Dict_1214_0_16, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile), -1, 0, 1, 1, 1, 0, "u 'PZdabFile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PZdabFile", 975, G__RAT_Dict_1214_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1214_0_18, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_PZdabFile), -1, 1, 1, 1, 1, 0, "u 'PZdabFile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdabcLcLzdabfile(void) {
   /* ratzdab::zdabfile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile));
   G__memfunc_setup("zdabfile",833,G__RAT_Dict_1216_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile), -1, 0, 1, 1, 1, 0, "u 'string' - 0 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("next",447,G__RAT_Dict_1216_0_2, 85, G__get_linked_tagnum(&G__RAT_DictLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("convert",769,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RAT_DictLN_TObject), -1, 0, 1, 1, 2, 0, "U 'nZDAB' - 40 - z", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("zdabfile", 833, G__RAT_Dict_1216_0_4, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfile), -1, 0, 1, 1, 1, 0, "u 'ratzdab::zdabfile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~zdabfile", 959, G__RAT_Dict_1216_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncratzdabcLcLzdabfilecLcLzdab_file_read_error(void) {
   /* ratzdab::zdabfile::zdab_file_read_error */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error));
   G__memfunc_setup("what",436,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 0, 1, 4, 41, "", (char*)NULL, (void*) NULL, 1);
   // automatic default constructor
   G__memfunc_setup("zdab_file_read_error", 2084, G__RAT_Dict_1217_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("zdab_file_read_error", 2084, G__RAT_Dict_1217_0_3, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error), -1, 0, 1, 1, 1, 0, "u 'ratzdab::zdabfile::zdab_file_read_error' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~zdab_file_read_error", 2210, G__RAT_Dict_1217_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncManipRopeStatus(void) {
   /* ManipRopeStatus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus));
   // automatic default constructor
   G__memfunc_setup("ManipRopeStatus", 1551, G__RAT_Dict_1225_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ManipRopeStatus", 1551, G__RAT_Dict_1225_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus), -1, 0, 1, 1, 1, 0, "u 'ManipRopeStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ManipRopeStatus", 1677, G__RAT_Dict_1225_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1225_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_ManipRopeStatus), -1, 1, 1, 1, 1, 0, "u 'ManipRopeStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncMTCReadoutData(void) {
   /* MTCReadoutData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData));
   // automatic default constructor
   G__memfunc_setup("MTCReadoutData", 1330, G__RAT_Dict_1237_0_1, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MTCReadoutData", 1330, G__RAT_Dict_1237_0_2, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData), -1, 0, 1, 1, 1, 0, "u 'MTCReadoutData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MTCReadoutData", 1456, G__RAT_Dict_1237_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1237_0_4, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_MTCReadoutData), -1, 1, 1, 1, 1, 0, "u 'MTCReadoutData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLutil(void) {
   /* RAT::util */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLutil));
   G__memfunc_setup("EnergyToWavelength",1858,G__RAT_Dict_1254_0_1, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 11 - energy", (char*)NULL, (void*) G__func2void( (double (*)(const double&))(&RAT::util::EnergyToWavelength) ), 0);
   G__memfunc_setup("WavelengthToEnergy",1858,G__RAT_Dict_1254_0_2, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 11 - wavelength", (char*)NULL, (void*) G__func2void( (double (*)(const double&))(&RAT::util::WavelengthToEnergy) ), 0);
   G__memfunc_setup("round_2_int",1123,G__RAT_Dict_1254_0_3, 105, -1, -1, 0, 1, 1, 1, 0, "d - - 11 - value", (char*)NULL, (void*) G__func2void( (int (*)(const double&))(&RAT::util::round_2_int) ), 0);
   G__memfunc_setup("round_2_int",1123,G__RAT_Dict_1254_0_4, 105, -1, -1, 0, 1, 1, 1, 0, "f - - 11 - value", (char*)NULL, (void*) G__func2void( (int (*)(const float&))(&RAT::util::round_2_int) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLEnergySystematics(void) {
   /* RAT::DU::EnergySystematics */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics));
   G__memfunc_setup("EnergySystematics",1795,G__RAT_Dict_1282_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics), -1, 0, 2, 1, 1, 0, 
"d - - 0 - _energy_scale d - - 0 - _resolution_uncertainty", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyEnergyResolution",2212,G__RAT_Dict_1282_0_2, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 11 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyEnergyScale",1624,G__RAT_Dict_1282_0_3, 100, -1, -1, 0, 2, 1, 1, 8, 
"d - - 11 - energy g - - 11 'false' direction", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1282_0_4, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::EnergySystematics::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1282_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EnergySystematics::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1282_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::EnergySystematics::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1282_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::EnergySystematics::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1282_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1282_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EnergySystematics::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1282_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::EnergySystematics::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1282_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::EnergySystematics::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1282_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::EnergySystematics::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("EnergySystematics", 1795, G__RAT_Dict_1282_0_16, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::EnergySystematics' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EnergySystematics", 1921, G__RAT_Dict_1282_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1282_0_18, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::EnergySystematics' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLDUcLcLPoint3D(void) {
   /* RAT::DU::Point3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1283_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Point3D::BeginOfRun) ), 0);
   G__memfunc_setup("GetSystemCount",1454,G__RAT_Dict_1283_0_2, 107, -1, G__defined_typename("size_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (size_t (*)())(&RAT::DU::Point3D::GetSystemCount) ), 0);
   G__memfunc_setup("HasZOffset",989,G__RAT_Dict_1283_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const size_t))(&RAT::DU::Point3D::HasZOffset) ), 0);
   G__memfunc_setup("GetZOffset",993,G__RAT_Dict_1283_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 3, 1, 0, "k - 'size_t' 10 - index", (char*)NULL, (void*) G__func2void( (Double_t (*)(const size_t))(&RAT::DU::Point3D::GetZOffset) ), 0);
   G__memfunc_setup("GetSystemName",1318,G__RAT_Dict_1283_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 1, "k - 'size_t' 10 - index", (char*)NULL, (void*) G__func2void( (const string (*)(const size_t))(&RAT::DU::Point3D::GetSystemName) ), 0);
   G__memfunc_setup("GetSystemDescription",2089,G__RAT_Dict_1283_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 1, 3, 1, 1, "k - 'size_t' 10 - index", (char*)NULL, (void*) G__func2void( (const string (*)(const size_t))(&RAT::DU::Point3D::GetSystemDescription) ), 0);
   G__memfunc_setup("GetSystemId",1106,G__RAT_Dict_1283_0_7, 107, -1, G__defined_typename("size_t"), 0, 1, 3, 1, 0, "u 'string' - 10 - name", (char*)NULL, (void*) G__func2void( (size_t (*)(const string))(&RAT::DU::Point3D::GetSystemId) ), 0);
   G__memfunc_setup("DumpSystemNames",1551,G__RAT_Dict_1283_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Point3D::DumpSystemNames) ), 0);
   G__memfunc_setup("Point3D",641,G__RAT_Dict_1283_0_9, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 1, 1, 1, 0, "k - 'size_t' 0 '0' id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Point3D",641,G__RAT_Dict_1283_0_10, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 1, 1, 1, 0, "u 'RAT::DU::Point3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Point3D",641,G__RAT_Dict_1283_0_11, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - id u 'RAT::DU::Point3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Point3D",641,G__RAT_Dict_1283_0_12, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 4, 1, 1, 0, 
"k - 'size_t' 0 - id d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetX",388,G__RAT_Dict_1283_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - - d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__RAT_Dict_1283_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - - d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__RAT_Dict_1283_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'size_t' 0 - id d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZ",567,G__RAT_Dict_1283_0_16, 121, -1, -1, 0, 4, 1, 1, 0, 
"k - 'size_t' 0 - id d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCoordinateSystem",1977,G__RAT_Dict_1283_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'size_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1283_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::Point3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCoordinateSystem",1965,G__RAT_Dict_1283_0_19, 107, -1, G__defined_typename("size_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X",88,G__RAT_Dict_1283_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Y",89,G__RAT_Dict_1283_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__RAT_Dict_1283_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__RAT_Dict_1283_0_23, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1283_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "k - 'size_t' 10 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__RAT_Dict_1283_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__RAT_Dict_1283_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CosTheta",795,G__RAT_Dict_1283_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__RAT_Dict_1283_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CosPhi",582,G__RAT_Dict_1283_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SinPhi",587,G__RAT_Dict_1283_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__RAT_Dict_1283_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEquivalentTo",1437,G__RAT_Dict_1283_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"u 'RAT::DU::Point3D' - 11 - p d - 'Double_t' 0 '2.22e-16' precision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reflection",1035,G__RAT_Dict_1283_0_33, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectionFrom",1621,G__RAT_Dict_1283_0_34, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 0, 1, 1, 1, 8, "u 'RAT::DU::Point3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewPoint",1108,G__RAT_Dict_1283_0_35, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 0, 1, 1, 1, 8, "u 'TVector3' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Move",407,G__RAT_Dict_1283_0_36, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 1, 1, 1, 0, "u 'TVector3' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__RAT_Dict_1283_0_37, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 1, 1, 1, 0, "u 'TVector3' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Midpoint",836,G__RAT_Dict_1283_0_38, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 1, 1, 1, 0, "u 'RAT::DU::Point3D' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__RAT_Dict_1283_0_39, 85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RAT::DU::Point3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__RAT_Dict_1283_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Point3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__RAT_Dict_1283_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RAT::DU::Point3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__RAT_Dict_1283_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::DU::Point3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RAT_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__RAT_Dict_1283_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__RAT_Dict_1283_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Point3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__RAT_Dict_1283_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Point3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__RAT_Dict_1283_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RAT::DU::Point3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__RAT_Dict_1283_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RAT::DU::Point3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Point3D", 767, G__RAT_Dict_1283_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLPcLcLLightPath(void) {
   /* RAT::LP::LightPath */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1285_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::LP::LightPath::BeginOfRun) ), 0);
   G__memfunc_setup("GetRI",443,G__RAT_Dict_1285_0_2, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 1, 0, 
"i 'RAT::LP::LightPath::RegionType' - 10 - regionType d - 'Double_t' 10 - energy", (char*)NULL, (void*) G__func2void( (Double_t (*)(const RAT::LP::LightPath::RegionType, const Double_t))(&RAT::LP::LightPath::GetRI) ), 0);
   G__memfunc_setup("LightPath",901,G__RAT_Dict_1285_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LightPath",901,G__RAT_Dict_1285_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - energy u 'RAT::DU::Point3D' - 11 - start "
"u 'RAT::DU::Point3D' - 11 - stop i 'RAT::LP::LightPath::RegionType' - 10 - startRegion "
"i 'RAT::LP::LightPath::RegionType' - 10 'Undefined' stopRegion", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__RAT_Dict_1285_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitter",910,G__RAT_Dict_1285_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitter",922,G__RAT_Dict_1285_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 0, "u 'string' - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergy",906,G__RAT_Dict_1285_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergy",918,G__RAT_Dict_1285_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointCount",1331,G__RAT_Dict_1285_0_10, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPoint",810,G__RAT_Dict_1285_0_11, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__RAT_Dict_1285_0_12, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 1, 1, 1, 1, 9, "h - 'UInt_t' 0 - initialPoint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRegionType",1318,G__RAT_Dict_1285_0_13, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - initialPoint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndPos",873,G__RAT_Dict_1285_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D), -1, 1, 0, 1, 1, 9, "", "actual end position", (void*) NULL, 0);
   G__memfunc_setup("GetIncidentVecOnPMT",1818,G__RAT_Dict_1285_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 1, 0, 1, 1, 9, "", "or -2?", (void*) NULL, 0);
   G__memfunc_setup("GetInitialLightVec",1792,G__RAT_Dict_1285_0_16, 117, G__get_linked_tagnum(&G__RAT_DictLN_TVector3), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__RAT_Dict_1285_0_17, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearPoints",1124,G__RAT_Dict_1285_0_18, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPoint",787,G__RAT_Dict_1285_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 3, 1, 1, 0, 
"u 'RAT::DU::Point3D' - 11 - pos u 'TVector3' - 11 - dir "
"i 'RAT::LP::LightPath::RegionType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoint",822,G__RAT_Dict_1285_0_20, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - point u 'RAT::DU::Point3D' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRegionType",1330,G__RAT_Dict_1285_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - point i 'RAT::LP::LightPath::RegionType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertPoint",1151,G__RAT_Dict_1285_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - point u 'RAT::DU::Point3D' - 11 - pos "
"i 'RAT::LP::LightPath::RegionType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeletePoint",1117,G__RAT_Dict_1285_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 0, "h - 'UInt_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalDist",1208,G__RAT_Dict_1285_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDist",692,G__RAT_Dict_1285_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - segment", "distance in specified segment", (void*) NULL, 0);
   G__memfunc_setup("GetDistByRegionType",1909,G__RAT_Dict_1285_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i 'RAT::LP::LightPath::RegionType' - 0 - regtype", "aggregate distance in a region type", (void*) NULL, 0);
   G__memfunc_setup("GetTotalTime",1203,G__RAT_Dict_1285_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCosThetaPMT",1324,G__RAT_Dict_1285_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - pmtID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadRefractiveIndex",1923,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"u 'simple_ptr_nocopy<RAT::DBLink>' 'RAT::DBLinkPtr' 0 - dbTable u 'TGraph' - 1 - property", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("LightPath", 901, G__RAT_Dict_1285_0_30, (int) ('i'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 0, 1, 1, 1, 0, "u 'RAT::LP::LightPath' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LightPath", 1027, G__RAT_Dict_1285_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1285_0_32, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 0, "u 'RAT::LP::LightPath' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLPcLcLLightPathFitter(void) {
   /* RAT::LP::LightPathFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter));
   G__memfunc_setup("Fit",291,G__RAT_Dict_1295_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 8, "u 'RAT::LP::LightPath' - 1 - startPath", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSolidAngle",1282,G__RAT_Dict_1295_0_3, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"u 'RAT::LP::LightPath' - 11 - lightPath u 'TVector3' - 11 - pmtNorm "
"h - 'UInt_t' 0 - nVal d - 'Double_t' 1 - cosThetaAvg", (char*)NULL, (void*) NULL, 3);
   // automatic destructor
   G__memfunc_setup("~LightPathFitter", 1649, G__RAT_Dict_1295_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1295_0_5, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter), -1, 1, 1, 1, 1, 0, "u 'RAT::LP::LightPathFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLPcLcLLightPathStraightFitter(void) {
   /* RAT::LP::LightPathStraightFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1296_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::LP::LightPathStraightFitter::BeginOfRun) ), 0);
   G__memfunc_setup("GetNeckInnerRadius",1797,G__RAT_Dict_1296_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetNeckInnerRadius) ), 0);
   G__memfunc_setup("GetNeckOuterRadius",1816,G__RAT_Dict_1296_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetNeckOuterRadius) ), 0);
   G__memfunc_setup("GetAVInnerRadius",1563,G__RAT_Dict_1296_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetAVInnerRadius) ), 0);
   G__memfunc_setup("GetAVOuterRadius",1582,G__RAT_Dict_1296_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetAVOuterRadius) ), 0);
   G__memfunc_setup("GetPMTRadius",1145,G__RAT_Dict_1296_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetPMTRadius) ), 0);
   G__memfunc_setup("GetFillZ",769,G__RAT_Dict_1296_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&RAT::LP::LightPathStraightFitter::GetFillZ) ), 0);
   G__memfunc_setup("Name",385,G__RAT_Dict_1296_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (string (*)())(&RAT::LP::LightPathStraightFitter::Name) ), 0);
   G__memfunc_setup("LightPathStraightFitter",2361,G__RAT_Dict_1296_0_9, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 8, "u 'RAT::LP::LightPath' - 1 - startPath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSolidAngle",1282,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"u 'RAT::LP::LightPath' - 11 - lightPath u 'TVector3' - 11 - pmtNorm "
"h - 'UInt_t' 0 - nVal d - 'Double_t' 1 - cosThetaAvg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegionType",1318,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType), -1, 0, 1, 3, 4, 0, "u 'RAT::DU::Point3D' - 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 3, 4, 0, 
"u 'RAT::LP::LightPath' - 1 - path u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - ts "
"u 'RAT::DU::Point3D' - 11 - p d - 'Double_t' 0 - t "
"i 'RAT::LP::LightPath::RegionType' - 0 - rtype", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("LightPathStraightFitter", 2361, G__RAT_Dict_1296_0_14, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter), -1, 0, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LightPathStraightFitter", 2487, G__RAT_Dict_1296_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1296_0_16, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter), -1, 1, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightFitter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLPcLcLLightPathStraightScint(void) {
   /* RAT::LP::LightPathStraightScint */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1297_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::LP::LightPathStraightScint::BeginOfRun) ), 0);
   G__memfunc_setup("Name",385,G__RAT_Dict_1297_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (string (*)())(&RAT::LP::LightPathStraightScint::Name) ), 0);
   G__memfunc_setup("LightPathStraightScint",2252,G__RAT_Dict_1297_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 8, "u 'RAT::LP::LightPath' - 1 - startPath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSolidAngle",1282,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"u 'RAT::LP::LightPath' - 11 - lightPath u 'TVector3' - 11 - pmtNorm "
"h - 'UInt_t' 0 - nVal d - 'Double_t' 1 - cosThetaAvg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPath",685,G__RAT_Dict_1297_0_6, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TVector3' - 0 - fPMTpos u 'TVector3' - 0 - fVertex "
"d - - 1 - distInWater d - - 1 - distInScint", (char*)NULL, (void*) G__func2void( (void (*)(TVector3, TVector3, double&, double&))(&RAT::LP::LightPathStraightScint::GetPath) ), 0);
   // automatic copy constructor
   G__memfunc_setup("LightPathStraightScint", 2252, G__RAT_Dict_1297_0_7, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint), -1, 0, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightScint' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LightPathStraightScint", 2378, G__RAT_Dict_1297_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1297_0_9, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint), -1, 1, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightScint' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRATcLcLLPcLcLLightPathStraightScintWater(void) {
   /* RAT::LP::LightPathStraightScintWater */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater));
   G__memfunc_setup("BeginOfRun",975,G__RAT_Dict_1298_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RAT::LP::LightPathStraightScintWater::BeginOfRun) ), 0);
   G__memfunc_setup("Name",385,G__RAT_Dict_1298_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (string (*)())(&RAT::LP::LightPathStraightScintWater::Name) ), 0);
   G__memfunc_setup("LightPathStraightScintWater",2767,G__RAT_Dict_1298_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fit",291,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPath), -1, 1, 1, 1, 1, 8, "u 'RAT::LP::LightPath' - 1 - startPath", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSolidAngle",1282,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"u 'RAT::LP::LightPath' - 11 - lightPath u 'TVector3' - 11 - pmtNorm "
"h - 'UInt_t' 0 - nVal d - 'Double_t' 1 - cosThetaAvg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPath",685,G__RAT_Dict_1298_0_6, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'TVector3' - 0 - fPMTpos u 'TVector3' - 0 - fVertex "
"d - - 1 - distInWater d - - 1 - distInScint", (char*)NULL, (void*) G__func2void( (void (*)(TVector3, TVector3, double&, double&))(&RAT::LP::LightPathStraightScintWater::GetPath) ), 0);
   // automatic copy constructor
   G__memfunc_setup("LightPathStraightScintWater", 2767, G__RAT_Dict_1298_0_7, (int) ('i'), 
G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater), -1, 0, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightScintWater' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LightPathStraightScintWater", 2893, G__RAT_Dict_1298_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__RAT_Dict_1298_0_9, (int) ('u'), G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater), -1, 1, 1, 1, 1, 0, "u 'RAT::LP::LightPathStraightScintWater' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR(void) {
   /* map<string,string,less<string>,allocator<pair<const string,string> > > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR));
   G__memfunc_setup("map<string,string,less<string>,allocator<pair<const string,string> > >",6772,G__RAT_Dict_1301_0_1, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<string,string,less<string>,allocator<pair<const string,string> > >",6772,G__RAT_Dict_1301_0_2, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - first u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<string,string,less<string>,allocator<pair<const string,string> > >",6772,G__RAT_Dict_1301_0_3, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator' - 0 - first u 'map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("map<string,string,less<string>,allocator<pair<const string,string> > >",6772,G__RAT_Dict_1301_0_4, 105, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'map<string,string,less<string>,allocator<pair<const string,string> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1301_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'map<string,string,less<string>,allocator<pair<const string,string> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_1301_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_1301_0_7, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_1301_0_8, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_1301_0_9, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_1301_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_1301_0_11, 107, -1, G__defined_typename("map<string,string,less<string>,allocator<pair<const string,string> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_1301_0_12, 107, -1, G__defined_typename("map<string,string,less<string>,allocator<pair<const string,string> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1301_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_string), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1301_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_pairlEmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "u 'pair<string,string>' 'map<string,string,less<string>,allocator<pair<const string,string> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1301_0_15, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - position u 'pair<string,string>' 'map<string,string,less<string>,allocator<pair<const string,string> > >::value_type' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1301_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - first u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1301_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator' - 0 - first u 'map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1301_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1301_0_19, 107, -1, G__defined_typename("map<string,string,less<string>,allocator<pair<const string,string> > >::size_type"), 0, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1301_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - first u 'map<string,string,less<string>,allocator<pair<const string,string> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_1301_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<string,string,less<string>,allocator<pair<const string,string> > >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1301_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__RAT_Dict_1301_0_23, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__RAT_Dict_1301_0_24, 107, -1, G__defined_typename("map<string,string,less<string>,allocator<pair<const string,string> > >::size_type"), 0, 1, 1, 1, 8, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__RAT_Dict_1301_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__RAT_Dict_1301_0_26, 117, G__get_linked_tagnum(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~map<string,string,less<string>,allocator<pair<const string,string> > >", 6898, G__RAT_Dict_1301_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR(void) {
   /* vector<RAT::TrackNode,allocator<RAT::TrackNode> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_1306_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_1306_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_1306_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_1306_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_1306_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_1306_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_1306_0_7, 107, -1, G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_1306_0_8, 107, -1, G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1306_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1306_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - sz u 'RAT::TrackNode' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_1306_0_11, 107, -1, G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_1306_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1306_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1306_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), G__defined_typename("vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode,allocator<RAT::TrackNode> >",4416,G__RAT_Dict_1306_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode,allocator<RAT::TrackNode> >",4416,G__RAT_Dict_1306_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n u 'RAT::TrackNode' - 11 'RAT::TrackNode()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode,allocator<RAT::TrackNode> >",4416,G__RAT_Dict_1306_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::TrackNode,allocator<RAT::TrackNode> >",4416,G__RAT_Dict_1306_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator' 10 - first u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1306_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_1306_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_1306_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_1306_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLTrackNode), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_1306_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::TrackNode' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_1306_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1306_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - position u 'RAT::TrackNode' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1306_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - position u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator' 10 - first "
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1306_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - position k - 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::size_type' 0 - n "
"u 'RAT::TrackNode' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_1306_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1306_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1306_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - first u 'vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1306_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::TrackNode,allocator<RAT::TrackNode> >", 4542, G__RAT_Dict_1306_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR(void) {
   /* vector<RAT::DBTable,allocator<RAT::DBTable> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR));
   G__memfunc_setup("at",213,G__RAT_Dict_1310_0_1, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("at",213,G__RAT_Dict_1310_0_2, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__RAT_Dict_1310_0_3, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__RAT_Dict_1310_0_4, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__RAT_Dict_1310_0_5, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__RAT_Dict_1310_0_6, 117, G__get_linked_tagnum(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__RAT_Dict_1310_0_7, 107, -1, G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__RAT_Dict_1310_0_8, 107, -1, G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1310_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__RAT_Dict_1310_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - sz u 'RAT::DBTable' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__RAT_Dict_1310_0_11, 107, -1, G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__RAT_Dict_1310_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1310_0_13, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::reference"), 1, 1, 1, 1, 0, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__RAT_Dict_1310_0_14, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), G__defined_typename("vector<RAT::DBTable,allocator<RAT::DBTable> >::const_reference"), 1, 1, 1, 1, 8, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable,allocator<RAT::DBTable> >",3878,G__RAT_Dict_1310_0_15, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable,allocator<RAT::DBTable> >",3878,G__RAT_Dict_1310_0_16, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR), -1, 0, 2, 1, 1, 0, 
"k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n u 'RAT::DBTable' - 11 'RAT::DBTable()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable,allocator<RAT::DBTable> >",3878,G__RAT_Dict_1310_0_17, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable,allocator<RAT::DBTable> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<RAT::DBTable,allocator<RAT::DBTable> >",3878,G__RAT_Dict_1310_0_18, 105, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' 'vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator' 10 - first u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' 'vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__RAT_Dict_1310_0_19, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<RAT::DBTable,allocator<RAT::DBTable> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__RAT_Dict_1310_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__RAT_Dict_1310_0_21, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__RAT_Dict_1310_0_22, 117, G__get_linked_tagnum(&G__RAT_DictLN_RATcLcLDBTable), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__RAT_Dict_1310_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RAT::DBTable' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__RAT_Dict_1310_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable,allocator<RAT::DBTable> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1310_0_25, 117, G__get_linked_tagnum(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - position u 'RAT::DBTable' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1310_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - position u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' 'vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator' 10 - first "
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' 'vector<RAT::DBTable,allocator<RAT::DBTable> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__RAT_Dict_1310_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - position k - 'vector<RAT::DBTable,allocator<RAT::DBTable> >::size_type' 0 - n "
"u 'RAT::DBTable' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__RAT_Dict_1310_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1310_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__RAT_Dict_1310_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - first u 'vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__RAT_Dict_1310_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<RAT::DBTable,allocator<RAT::DBTable> >", 4004, G__RAT_Dict_1310_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncRAT_Dict() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalRAT_Dict() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {
}

static void G__cpp_setup_func28() {
}

static void G__cpp_setup_func29() {
}

static void G__cpp_setup_func30() {
}

static void G__cpp_setup_func31() {
}

static void G__cpp_setup_func32() {
}

static void G__cpp_setup_func33() {
}

static void G__cpp_setup_func34() {
}

static void G__cpp_setup_func35() {
}

static void G__cpp_setup_func36() {
}

static void G__cpp_setup_func37() {
}

static void G__cpp_setup_func38() {
}

static void G__cpp_setup_func39() {
}

static void G__cpp_setup_func40() {
}

static void G__cpp_setup_func41() {
}

static void G__cpp_setup_func42() {
}

static void G__cpp_setup_func43() {
}

static void G__cpp_setup_func44() {
}

static void G__cpp_setup_func45() {
}

static void G__cpp_setup_func46() {
}

static void G__cpp_setup_func47() {
}

static void G__cpp_setup_func48() {
}

static void G__cpp_setup_func49() {
}

static void G__cpp_setup_func50() {
}

static void G__cpp_setup_func51() {
}

static void G__cpp_setup_func52() {
}

static void G__cpp_setup_func53() {
}

static void G__cpp_setup_func54() {
}

static void G__cpp_setup_func55() {
}

static void G__cpp_setup_func56() {
}

static void G__cpp_setup_func57() {
}

static void G__cpp_setup_func58() {
}

static void G__cpp_setup_func59() {
}

static void G__cpp_setup_func60() {
}

static void G__cpp_setup_func61() {
}

static void G__cpp_setup_func62() {
}

static void G__cpp_setup_func63() {
}

static void G__cpp_setup_func64() {
}

static void G__cpp_setup_func65() {
}

static void G__cpp_setup_func66() {
}

static void G__cpp_setup_func67() {
   G__memfunc_setup("util_to_int", 1194, G__RAT_Dict__0_6876, 105, -1, -1, 0, 2, 1, 1, 32, 
"u 'string' - 11 - value h - - 0 '0' -", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func68() {
}

static void G__cpp_setup_func69() {
}

static void G__cpp_setup_func70() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcRAT_Dict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
  G__cpp_setup_func28();
  G__cpp_setup_func29();
  G__cpp_setup_func30();
  G__cpp_setup_func31();
  G__cpp_setup_func32();
  G__cpp_setup_func33();
  G__cpp_setup_func34();
  G__cpp_setup_func35();
  G__cpp_setup_func36();
  G__cpp_setup_func37();
  G__cpp_setup_func38();
  G__cpp_setup_func39();
  G__cpp_setup_func40();
  G__cpp_setup_func41();
  G__cpp_setup_func42();
  G__cpp_setup_func43();
  G__cpp_setup_func44();
  G__cpp_setup_func45();
  G__cpp_setup_func46();
  G__cpp_setup_func47();
  G__cpp_setup_func48();
  G__cpp_setup_func49();
  G__cpp_setup_func50();
  G__cpp_setup_func51();
  G__cpp_setup_func52();
  G__cpp_setup_func53();
  G__cpp_setup_func54();
  G__cpp_setup_func55();
  G__cpp_setup_func56();
  G__cpp_setup_func57();
  G__cpp_setup_func58();
  G__cpp_setup_func59();
  G__cpp_setup_func60();
  G__cpp_setup_func61();
  G__cpp_setup_func62();
  G__cpp_setup_func63();
  G__cpp_setup_func64();
  G__cpp_setup_func65();
  G__cpp_setup_func66();
  G__cpp_setup_func67();
  G__cpp_setup_func68();
  G__cpp_setup_func69();
  G__cpp_setup_func70();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__RAT_DictLN_tm = { "tm" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TRootIOCtor = { "TRootIOCtor" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR = { "vector<unsigned short,allocator<unsigned short> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEunsignedsPlongsPlongcOallocatorlEunsignedsPlongsPlonggRsPgR = { "vector<unsigned long long,allocator<unsigned long long> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_ostringstream<char,char_traits<char>,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RAT = { "RAT" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDS = { "RAT::DS" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLBitMask = { "RAT::DS::BitMask" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TVector2 = { "TVector2" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TVector3 = { "TVector3" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLCalib = { "RAT::DS::Calib" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_exception = { "exception" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_logic_error = { "logic_error" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_runtime_error = { "runtime_error" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLDataNotFound = { "RAT::DS::DataNotFound" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_lesslEstringgR = { "less<string>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR = { "map<int,int,less<int>,allocator<pair<const int,int> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLClassifierResult = { "RAT::DS::ClassifierResult" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR = { "map<string,Double32_t,less<string>,allocator<pair<const string,Double32_t> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLDataQCFlags = { "RAT::DS::DataQCFlags" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_lesslEunsignedsPintgR = { "less<unsigned int>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgR = { "allocator<pair<const unsigned int,RAT::DS::BitMask> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR = { "map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR = { "pair<unsigned int,RAT::DS::BitMask>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator = { "map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator = { "map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLDigitiser = { "RAT::DS::Digitiser" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR = { "map<unsigned short,vector<unsigned short,allocator<unsigned short> >,less<unsigned short>,allocator<pair<const unsigned short,vector<unsigned short,allocator<unsigned short> > > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLECAHeader = { "RAT::DS::ECAHeader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLUniversalTime = { "RAT::DS::UniversalTime" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag = { "ROOT::Math::DefaultCoordinateSystemTag" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR = { "ROOT::Math::Cartesian3D<double>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR = { "ROOT::Math::Cartesian3D<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::CylindricalEta3D<double>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::CylindricalEta3D<float>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR = { "ROOT::Math::Polar3D<double>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR = { "ROOT::Math::Polar3D<float>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Cylindrical3D<double>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR = { "ROOT::Math::DisplacementVector3D<ROOT::Math::Cylindrical3D<float>,ROOT::Math::DefaultCoordinateSystemTag>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLFitVertex = { "RAT::DS::FitVertex" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues = { "RAT::DS::FitVertex::EMaskValues" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLFitResult = { "RAT::DS::FitResult" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR = { "vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator = { "vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR = { "RAT::DS::FitClassifierCollection<RAT::DS::FitResult>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR = { "map<string,RAT::DS::FitResult,less<string>,allocator<pair<const string,RAT::DS::FitResult> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR = { "RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR = { "map<string,RAT::DS::ClassifierResult,less<string>,allocator<pair<const string,RAT::DS::ClassifierResult> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_omtext = { "omtext" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR = { "vector<otext,allocator<otext> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEotextcOallocatorlEotextgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<otext,allocator<otext> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR = { "vector<itext,allocator<itext> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEitextcOallocatorlEitextgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<itext,allocator<itext> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR = { "set<string,less<string>,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_json = { "json" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_jsoncLcLValue = { "json::Value" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR = { "map<string,json::Value,less<string>,allocator<pair<const string,json::Value> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR = { "vector<json::Value,allocator<json::Value> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<json::Value,allocator<json::Value> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_jsoncLcLTData = { "json::TData" , 117 , -1 };
G__linked_taginfo G__RAT_DictLN_jsoncLcLType = { "json::Type" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_oftext = { "oftext" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLog = { "RAT::Log" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLogcLcLLevel = { "RAT::Log::Level" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLBitManip = { "RAT::BitManip" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTCal = { "RAT::DS::PMTCal" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR = { "RAT::DS::PMT<Double32_t>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR = { "RAT::DS::PMT<unsigned short>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCHit = { "RAT::DS::MCHit" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDU = { "RAT::DU" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPMTInfo = { "RAT::DU::PMTInfo" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType = { "RAT::DU::PMTInfo::EPMTType" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus = { "RAT::DU::PMTInfo::EPetalStatus" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR = { "vector<TVector3,allocator<TVector3> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlETVector3cOallocatorlETVector3gRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVector3,allocator<TVector3> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR = { "vector<RAT::DU::PMTInfo::EPMTType,allocator<RAT::DU::PMTInfo::EPMTType> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DU::PMTInfo::EPMTType,allocator<RAT::DU::PMTInfo::EPMTType> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR = { "vector<RAT::DU::PMTInfo::EPetalStatus,allocator<RAT::DU::PMTInfo::EPetalStatus> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DU::PMTInfo::EPetalStatus,allocator<RAT::DU::PMTInfo::EPetalStatus> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR = { "RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR = { "vector<RAT::DS::PMT<unsigned short>,allocator<RAT::DS::PMT<unsigned short> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::PMT<unsigned short>,allocator<RAT::DS::PMT<unsigned short> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR = { "RAT::DS::PMTSet<RAT::DS::PMTCal>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR = { "vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator = { "vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR = { "RAT::DS::PMTSet<RAT::DS::MCHit>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR = { "vector<RAT::DS::MCHit,allocator<RAT::DS::MCHit> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCHit,allocator<RAT::DS::MCHit> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLEV = { "RAT::DS::EV" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgR = { "allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR = { "map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR = { "pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator = { "map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator = { "map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgR = { "allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR = { "pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgR = { "allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR = { "pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator = { "map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR = { "vector<RAT::DS::Digitiser,allocator<RAT::DS::Digitiser> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::Digitiser,allocator<RAT::DS::Digitiser> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLTrigHeader = { "RAT::DS::TrigHeader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR = { "map<unsigned short,unsigned short,less<unsigned short>,allocator<pair<const unsigned short,unsigned short> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLHeaderInfo = { "RAT::DS::HeaderInfo" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR = { "vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator = { "vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR = { "vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator = { "vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMetaDB = { "RAT::DS::MetaDB" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEstringcOstringgR = { "pair<string,string>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR = { "vector<pair<string,string>,allocator<pair<string,string> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<string,string>,allocator<pair<string,string> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLRun = { "RAT::DS::Run" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMeta = { "RAT::DS::Meta" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLMetaHelper = { "RAT::MetaHelper" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR = { "vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator = { "vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCParticle = { "RAT::DS::MCParticle" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCTrackStep = { "RAT::DS::MCTrackStep" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus = { "RAT::DS::MCTrackStep::EStatus" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess = { "RAT::DS::MCTrackStep::EProcess" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCTrack = { "RAT::DS::MCTrack" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag = { "RAT::DS::MCTrack::ESummaryFlag" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR = { "set<unsigned long,less<unsigned long>,allocator<unsigned long> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR = { "vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator = { "vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPhoton = { "RAT::DS::MCPhoton" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate = { "RAT::DS::MCPhoton::EPhotonFate" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPE = { "RAT::DS::MCPE" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory = { "RAT::DS::MCPE::PhotonHistory" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhHistoryStatus = { "RAT::DS::MCPE::PhHistoryStatus" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCPMT = { "RAT::DS::MCPMT" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR = { "vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator = { "vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR = { "vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator = { "vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMC = { "RAT::DS::MC" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR = { "vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator = { "vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR = { "vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator = { "vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR = { "vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator = { "vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLMCEV = { "RAT::DS::MCEV" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLEntry = { "RAT::DS::Entry" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR = { "vector<RAT::DS::MC,allocator<RAT::DS::MC> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator = { "vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MC,allocator<RAT::DS::MC> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR = { "vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator = { "vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR = { "vector<RAT::DS::EV,allocator<RAT::DS::EV> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator = { "vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::EV,allocator<RAT::DS::EV> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR = { "vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator = { "vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLSOCPMT = { "RAT::DS::SOCPMT" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus = { "RAT::DS::SOCPMT::EPeakFindStatus" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDScLcLSOC = { "RAT::DS::SOC" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgR = { "allocator<pair<const unsigned int,RAT::DS::SOCPMT> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR = { "map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR = { "pair<unsigned int,RAT::DS::SOCPMT>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator = { "map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator = { "map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR = { "map<string,RAT::DS::SOC,less<string>,allocator<pair<const string,RAT::DS::SOC> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits = { "RAT::DU::DataCleaningBits" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit = { "RAT::DU::DataCleaningBits::Bit" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR = { "map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator = { "map<string,unsigned long,less<string>,allocator<pair<const string,unsigned long> > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR = { "map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator = { "map<unsigned long,string,less<unsigned long>,allocator<pair<const unsigned long,string> > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits = { "RAT::DU::DataQualityBits" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit = { "RAT::DU::DataQualityBits::Bit" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus = { "RAT::DU::ChanSWStatus" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit = { "RAT::DU::ChanSWStatus::Bit" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLTrigBits = { "RAT::DU::TrigBits" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA = { "RAT::DU::TrigBits::$" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TChain = { "TChain" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLDSReader = { "RAT::DU::DSReader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity = { "RAT::DU::EffectiveVelocity" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_complexlEdoublegR = { "complex<double>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEboolcOunsignedsPintgR = { "pair<bool,unsigned int>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_stlplus = { "stlplus" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBTable = { "RAT::DBTable" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBTablecLcLFieldType = { "RAT::DBTable::FieldType" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_stlpluscLcLhashlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRsPgR = { "stlplus::hash<string,RAT::DBTable::FieldType,RAT::pyhash,equal_to<string> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEstlpluscLcLhash_iteratorlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRcOpairlEconstsPstringcORATcLcLDBTablecLcLFieldTypegRsPgRcOboolgR = { "pair<stlplus::hash_iterator<string,RAT::DBTable::FieldType,RAT::pyhash,equal_to<string>,pair<const string,RAT::DBTable::FieldType> >,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDB = { "RAT::DB" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBLink = { "RAT::DBLink" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLPgSQLBackend = { "RAT::PgSQLBackend" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBTableKey = { "RAT::DBTableKey" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR = { "simple_ptr_nocopy<RAT::DBTable>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR = { "map<RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable>,less<RAT::DBTableKey>,allocator<pair<const RAT::DBTableKey,simple_ptr_nocopy<RAT::DBTable> > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR = { "simple_ptr_nocopy<RAT::DBLink>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR = { "map<string,simple_ptr_nocopy<RAT::DBLink>,less<string>,allocator<pair<const string,simple_ptr_nocopy<RAT::DBLink> > > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR = { "vector<RAT::DBTable*,allocator<RAT::DBTable*> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator = { "vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DBTable*,allocator<RAT::DBTable*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR = { "map<pair<string,string>,int,less<pair<string,string> >,allocator<pair<const pair<string,string>,int> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_listlERATcLcLDBLinkmUcOallocatorlERATcLcLDBLinkmUgRsPgR = { "list<RAT::DBLink*,allocator<RAT::DBLink*> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR = { "set<RAT::DBTableKey,less<RAT::DBTableKey>,allocator<RAT::DBTableKey> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_dequelERATcLcLDBTableKeycOallocatorlERATcLcLDBTableKeygRsPgR = { "deque<RAT::DBTableKey,allocator<RAT::DBTableKey> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity = { "RAT::DU::GroupVelocity" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLeLightPathType = { "RAT::DU::eLightPathType" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator = { "RAT::DU::LightPathCalculator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR = { "map<RAT::DU::eLightPathType,string,less<RAT::DU::eLightPathType>,allocator<pair<const RAT::DU::eLightPathType,string> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPanelInfo = { "RAT::DU::PanelInfo" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType = { "RAT::DU::PanelInfo::EPanelType" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR = { "vector<RAT::DU::PanelInfo::EPanelType,allocator<RAT::DU::PanelInfo::EPanelType> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DU::PanelInfo::EPanelType,allocator<RAT::DU::PanelInfo::EPanelType> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus = { "RAT::DU::ChanHWStatus" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus = { "RAT::DU::PMTCalStatus" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA = { "RAT::DU::PMTCalStatus::$" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc = { "RAT::DU::ReactorNuOsc" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator = { "RAT::DU::ShadowingCalculator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLSegmentor = { "RAT::DU::Segmentor" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLSOCReader = { "RAT::DU::SOCReader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLReconCorrector = { "RAT::DU::ReconCorrector" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator = { "RAT::DU::ReconCalibrator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLFitterPMT = { "RAT::FitterPMT" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator = { "RAT::DU::TimeResidualCalculator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLUtility = { "RAT::DU::Utility" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLTrackNode = { "RAT::TrackNode" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR = { "vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator = { "vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLTrackTest = { "RAT::TrackTest" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_unary_functionlERATcLcLTrackNodemUcOboolgR = { "unary_function<RAT::TrackNode*,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLTrackCursor = { "RAT::TrackCursor" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLTrackNav = { "RAT::TrackNav" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR = { "map<int,RAT::TrackNode*,less<int>,allocator<pair<const int,RAT::TrackNode*> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pg_conn = { "pg_conn" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_pg_result = { "pg_result" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_pgNotify = { "pgNotify" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBCommandLoader = { "RAT::DBCommandLoader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_dequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgR = { "deque<RAT::Tokenizer,allocator<RAT::Tokenizer> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_stacklERATcLcLTokenizercOdequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgRsPgR = { "stack<RAT::Tokenizer,deque<RAT::Tokenizer,allocator<RAT::Tokenizer> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBTextLoader = { "RAT::DBTextLoader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDBJsonLoader = { "RAT::DBJsonLoader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLHTTPDownloader = { "RAT::HTTPDownloader" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLMetaInformation = { "RAT::MetaInformation" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_PmtEventRecord = { "PmtEventRecord" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RunRecord = { "RunRecord" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_TriggerInfo = { "TriggerInfo" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_EpedRecord = { "EpedRecord" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdab = { "ratzdab" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLunpack = { "ratzdab::unpack" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLpack = { "ratzdab::pack" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR = { "map<int,float,less<int>,allocator<pair<const int,float> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLunknown_record_error = { "ratzdab::unknown_record_error" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_PZdabFile = { "PZdabFile" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_nZDAB = { "nZDAB" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLzdabfile = { "ratzdab::zdabfile" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error = { "ratzdab::zdabfile::zdab_file_read_error" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_ManipRopeStatus = { "ManipRopeStatus" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_MTCReadoutData = { "MTCReadoutData" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_ratzdabcLcLPMTCal = { "ratzdab::PMTCal" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_PZdabFilecLcLzdab_file_unexpected_eof = { "PZdabFile::zdab_file_unexpected_eof" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLutil = { "RAT::util" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_CLHEP = { "CLHEP" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_CLHEPcLcLHep3Vector = { "CLHEP::Hep3Vector" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics = { "RAT::DU::EnergySystematics" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLDUcLcLPoint3D = { "RAT::DU::Point3D" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLP = { "RAT::LP" , 110 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPath = { "RAT::LP::LightPath" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType = { "RAT::LP::LightPath::RegionType" , 101 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR = { "vector<RAT::DU::Point3D,allocator<RAT::DU::Point3D> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DU::Point3D,allocator<RAT::DU::Point3D> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR = { "vector<RAT::LP::LightPath::RegionType,allocator<RAT::LP::LightPath::RegionType> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::LP::LightPath::RegionType,allocator<RAT::LP::LightPath::RegionType> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter = { "RAT::LP::LightPathFitter" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter = { "RAT::LP::LightPathStraightFitter" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint = { "RAT::LP::LightPathStraightScint" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater = { "RAT::LP::LightPathStraightScintWater" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_allocatorlEpairlEconstsPstringcOstringgRsPgR = { "allocator<pair<const string,string> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR = { "map<string,string,less<string>,allocator<pair<const string,string> > >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator = { "map<string,string,less<string>,allocator<pair<const string,string> > >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator = { "map<string,string,less<string>,allocator<pair<const string,string> > >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_pairlEmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiteratorcOboolgR = { "pair<map<string,string,less<string>,allocator<pair<const string,string> > >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR = { "vector<RAT::TrackNode,allocator<RAT::TrackNode> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator = { "vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::TrackNode,allocator<RAT::TrackNode> >::iterator>" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR = { "vector<RAT::DBTable,allocator<RAT::DBTable> >" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator = { "vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator" , 99 , -1 };
G__linked_taginfo G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RAT::DBTable,allocator<RAT::DBTable> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableRAT_Dict() {
  G__RAT_DictLN_tm.tagnum = -1 ;
  G__RAT_DictLN_TClass.tagnum = -1 ;
  G__RAT_DictLN_TBuffer.tagnum = -1 ;
  G__RAT_DictLN_TMemberInspector.tagnum = -1 ;
  G__RAT_DictLN_TObject.tagnum = -1 ;
  G__RAT_DictLN_TRootIOCtor.tagnum = -1 ;
  G__RAT_DictLN_ROOT.tagnum = -1 ;
  G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEunsignedsPlongsPlongcOallocatorlEunsignedsPlongsPlonggRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_string.tagnum = -1 ;
  G__RAT_DictLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RAT.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDS.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLBitMask.tagnum = -1 ;
  G__RAT_DictLN_TVector2.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__RAT_DictLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__RAT_DictLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_TVector3.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLCalib.tagnum = -1 ;
  G__RAT_DictLN_exception.tagnum = -1 ;
  G__RAT_DictLN_logic_error.tagnum = -1 ;
  G__RAT_DictLN_runtime_error.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLDataNotFound.tagnum = -1 ;
  G__RAT_DictLN_lesslEstringgR.tagnum = -1 ;
  G__RAT_DictLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLClassifierResult.tagnum = -1 ;
  G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLDataQCFlags.tagnum = -1 ;
  G__RAT_DictLN_lesslEunsignedsPintgR.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLDigitiser.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLECAHeader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLUniversalTime.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMath.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLFitVertex.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLFitResult.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_omtext.tagnum = -1 ;
  G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEotextcOallocatorlEotextgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEitextcOallocatorlEitextgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_TMap.tagnum = -1 ;
  G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__RAT_DictLN_json.tagnum = -1 ;
  G__RAT_DictLN_jsoncLcLValue.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_jsoncLcLTData.tagnum = -1 ;
  G__RAT_DictLN_jsoncLcLType.tagnum = -1 ;
  G__RAT_DictLN_oftext.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLog.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLogcLcLLevel.tagnum = -1 ;
  G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLBitManip.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTCal.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCHit.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDU.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPMTInfo.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus.tagnum = -1 ;
  G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlETVector3cOallocatorlETVector3gRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLEV.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLTrigHeader.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLHeaderInfo.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMetaDB.tagnum = -1 ;
  G__RAT_DictLN_pairlEstringcOstringgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLRun.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMeta.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLMetaHelper.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCParticle.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCTrackStep.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCTrack.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag.tagnum = -1 ;
  G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPhoton.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPE.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhHistoryStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCPMT.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMC.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLMCEV.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLEntry.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLSOCPMT.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDScLcLSOC.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLTrigBits.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_TChain.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLDSReader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity.tagnum = -1 ;
  G__RAT_DictLN_complexlEdoublegR.tagnum = -1 ;
  G__RAT_DictLN_pairlEboolcOunsignedsPintgR.tagnum = -1 ;
  G__RAT_DictLN_stlplus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBTable.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBTablecLcLFieldType.tagnum = -1 ;
  G__RAT_DictLN_stlpluscLcLhashlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pairlEstlpluscLcLhash_iteratorlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRcOpairlEconstsPstringcORATcLcLDBTablecLcLFieldTypegRsPgRcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDB.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBLink.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLPgSQLBackend.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBTableKey.tagnum = -1 ;
  G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR.tagnum = -1 ;
  G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_listlERATcLcLDBLinkmUcOallocatorlERATcLcLDBLinkmUgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR.tagnum = -1 ;
  G__RAT_DictLN_dequelERATcLcLDBTableKeycOallocatorlERATcLcLDBTableKeygRsPgR.tagnum = -1 ;
  G__RAT_DictLN_TGraph.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLeLightPathType.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator.tagnum = -1 ;
  G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPanelInfo.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLSegmentor.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLSOCReader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLReconCorrector.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLFitterPMT.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLUtility.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLTrackNode.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLTrackTest.tagnum = -1 ;
  G__RAT_DictLN_unary_functionlERATcLcLTrackNodemUcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLTrackCursor.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLTrackNav.tagnum = -1 ;
  G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_pg_conn.tagnum = -1 ;
  G__RAT_DictLN_pg_result.tagnum = -1 ;
  G__RAT_DictLN_pgNotify.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBCommandLoader.tagnum = -1 ;
  G__RAT_DictLN_dequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgR.tagnum = -1 ;
  G__RAT_DictLN_stacklERATcLcLTokenizercOdequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBTextLoader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDBJsonLoader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLHTTPDownloader.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLMetaInformation.tagnum = -1 ;
  G__RAT_DictLN_PmtEventRecord.tagnum = -1 ;
  G__RAT_DictLN_RunRecord.tagnum = -1 ;
  G__RAT_DictLN_TriggerInfo.tagnum = -1 ;
  G__RAT_DictLN_EpedRecord.tagnum = -1 ;
  G__RAT_DictLN_ratzdab.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLunpack.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLpack.tagnum = -1 ;
  G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLunknown_record_error.tagnum = -1 ;
  G__RAT_DictLN_PZdabFile.tagnum = -1 ;
  G__RAT_DictLN_nZDAB.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLzdabfile.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error.tagnum = -1 ;
  G__RAT_DictLN_ManipRopeStatus.tagnum = -1 ;
  G__RAT_DictLN_MTCReadoutData.tagnum = -1 ;
  G__RAT_DictLN_ratzdabcLcLPMTCal.tagnum = -1 ;
  G__RAT_DictLN_PZdabFilecLcLzdab_file_unexpected_eof.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLutil.tagnum = -1 ;
  G__RAT_DictLN_CLHEP.tagnum = -1 ;
  G__RAT_DictLN_CLHEPcLcLHep3Vector.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLDUcLcLPoint3D.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLP.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPath.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint.tagnum = -1 ;
  G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater.tagnum = -1 ;
  G__RAT_DictLN_allocatorlEpairlEconstsPstringcOstringgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__RAT_DictLN_pairlEmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR.tagnum = -1 ;
  G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator.tagnum = -1 ;
  G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableRAT_Dict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_tm);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TClass);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TObject);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TRootIOCtor);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOT);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEunsignedsPlongsPlongcOallocatorlEunsignedsPlongsPlonggRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_string);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RAT),0,-1,0,(char*)NULL,G__setup_memvarRAT,G__setup_memfuncRAT);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDS);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLBitMask),sizeof(RAT::DS::BitMask),-1,323840,(char*)NULL,G__setup_memvarRATcLcLDScLcLBitMask,G__setup_memfuncRATcLcLDScLcLBitMask);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TVector2);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TVector3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLCalib),sizeof(RAT::DS::Calib),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLCalib,G__setup_memfuncRATcLcLDScLcLCalib);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_exception),0,-1,134912,(char*)NULL,NULL,NULL);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_logic_error);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_runtime_error);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLDataNotFound),sizeof(RAT::DS::DataNotFound),-1,164864,(char*)NULL,G__setup_memvarRATcLcLDScLcLDataNotFound,G__setup_memfuncRATcLcLDScLcLDataNotFound);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_lesslEstringgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEintcOintcOlesslEintgRcOallocatorlEpairlEconstsPintcOintgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLClassifierResult),sizeof(RAT::DS::ClassifierResult),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLClassifierResult,G__setup_memfuncRATcLcLDScLcLClassifierResult);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcODouble32_tcOlesslEstringgRcOallocatorlEpairlEconstsPstringcODouble32_tgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLDataQCFlags),sizeof(RAT::DS::DataQCFlags),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLDataQCFlags,G__setup_memfuncRATcLcLDScLcLDataQCFlags);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_lesslEunsignedsPintgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR),sizeof(map<unsigned int,RAT::DS::BitMask,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::BitMask> > >),-1,298752,(char*)NULL,G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR,G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLBitMaskgR),sizeof(pair<unsigned int,RAT::DS::BitMask>),-1,297216,(char*)NULL,G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR,G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLBitMaskgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLBitMaskcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLBitMaskgRsPgRsPgRcLcLiteratorcOboolgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLDigitiser),sizeof(RAT::DS::Digitiser),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLDigitiser,G__setup_memfuncRATcLcLDScLcLDigitiser);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOvectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLECAHeader),sizeof(RAT::DS::ECAHeader),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLECAHeader,G__setup_memfuncRATcLcLDScLcLECAHeader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLUniversalTime),sizeof(RAT::DS::UniversalTime),-1,323840,(char*)NULL,G__setup_memvarRATcLcLDScLcLUniversalTime,G__setup_memfuncRATcLcLDScLcLUniversalTime);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMath);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDefaultCoordinateSystemTag);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR,G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLCartesian3DlEfloatgR),sizeof(ROOT::Math::Cartesian3D<float>),-1,297728,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLCartesian3DlEfloatgR,G__setup_memfuncROOTcLcLMathcLcLCartesian3DlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>,ROOT::Math::DefaultCoordinateSystemTag>),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR,G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCartesian3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindricalEta3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<double>,ROOT::Math::DefaultCoordinateSystemTag>),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR,G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLPolar3DlEfloatgR),sizeof(ROOT::Math::Polar3D<float>),-1,297728,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLPolar3DlEfloatgR,G__setup_memfuncROOTcLcLMathcLcLPolar3DlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR),sizeof(ROOT::Math::DisplacementVector3D<ROOT::Math::Polar3D<float>,ROOT::Math::DefaultCoordinateSystemTag>),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR,G__setup_memfuncROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLPolar3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEdoublegRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ROOTcLcLMathcLcLDisplacementVector3DlEROOTcLcLMathcLcLCylindrical3DlEfloatgRcOROOTcLcLMathcLcLDefaultCoordinateSystemTaggR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLFitVertex),sizeof(RAT::DS::FitVertex),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLFitVertex,G__setup_memfuncRATcLcLDScLcLFitVertex);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLFitVertexcLcLEMaskValues);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLFitResult),sizeof(RAT::DS::FitResult),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLFitResult,G__setup_memfuncRATcLcLDScLcLFitResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR),sizeof(vector<RAT::DS::FitVertex,allocator<RAT::DS::FitVertex> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLFitVertexcOallocatorlERATcLcLDScLcLFitVertexgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR),sizeof(RAT::DS::FitClassifierCollection<RAT::DS::FitResult>),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR,G__setup_memfuncRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLFitResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLFitResultgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR),sizeof(RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR,G__setup_memfuncRATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLClassifierResultcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLClassifierResultgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_omtext);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEotextcOallocatorlEotextgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEotextcOallocatorlEotextgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEitextcOallocatorlEitextgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEitextcOallocatorlEitextgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TMap);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_json);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_jsoncLcLValue),sizeof(json::Value),-1,36608,(char*)NULL,G__setup_memvarjsoncLcLValue,G__setup_memfuncjsoncLcLValue);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOjsoncLcLValuecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOjsoncLcLValuegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEjsoncLcLValuecOallocatorlEjsoncLcLValuegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_jsoncLcLTData);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_jsoncLcLType);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_oftext);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLog),sizeof(RAT::Log),-1,295168,(char*)NULL,G__setup_memvarRATcLcLLog,G__setup_memfuncRATcLcLLog);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLogcLcLLevel);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLBitManip),sizeof(RAT::BitManip),-1,263424,(char*)NULL,G__setup_memvarRATcLcLBitManip,G__setup_memfuncRATcLcLBitManip);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTCal),sizeof(RAT::DS::PMTCal),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTCal,G__setup_memfuncRATcLcLDScLcLPMTCal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTlEDouble32_tgR),sizeof(RAT::DS::PMT<Double32_t>),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTlEDouble32_tgR,G__setup_memfuncRATcLcLDScLcLPMTlEDouble32_tgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTlEunsignedsPshortgR),sizeof(RAT::DS::PMT<unsigned short>),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTlEunsignedsPshortgR,G__setup_memfuncRATcLcLDScLcLPMTlEunsignedsPshortgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCHit),sizeof(RAT::DS::MCHit),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCHit,G__setup_memfuncRATcLcLDScLcLMCHit);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDU);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfo),sizeof(RAT::DU::PMTInfo),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLPMTInfo,G__setup_memfuncRATcLcLDUcLcLPMTInfo);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPMTType);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPMTInfocLcLEPetalStatus);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlETVector3cOallocatorlETVector3gRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlETVector3cOallocatorlETVector3gRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPMTTypecOallocatorlERATcLcLDUcLcLPMTInfocLcLEPMTTypegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPMTInfocLcLEPetalStatuscOallocatorlERATcLcLDUcLcLPMTInfocLcLEPetalStatusgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR),sizeof(RAT::DS::PMTSet<RAT::DS::PMT<unsigned short> >),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR,G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTlEunsignedsPshortgRcOallocatorlERATcLcLDScLcLPMTlEunsignedsPshortgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR),sizeof(RAT::DS::PMTSet<RAT::DS::PMTCal>),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR,G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR),sizeof(vector<RAT::DS::PMTCal,allocator<RAT::DS::PMTCal> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLPMTCalcOallocatorlERATcLcLDScLcLPMTCalgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR),sizeof(RAT::DS::PMTSet<RAT::DS::MCHit>),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR,G__setup_memfuncRATcLcLDScLcLPMTSetlERATcLcLDScLcLMCHitgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCHitcOallocatorlERATcLcLDScLcLMCHitgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLEV),sizeof(RAT::DS::EV),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLEV,G__setup_memfuncRATcLcLDScLcLEV);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR),sizeof(map<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> > > >),-1,298752,(char*)NULL,G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR,G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR),sizeof(pair<unsigned int,RAT::DS::PMTSet<RAT::DS::PMTCal> >),-1,297216,(char*)NULL,G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR,G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLPMTSetlERATcLcLDScLcLPMTCalgRsPgRsPgRsPgRcLcLiteratorcOboolgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR),sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> > > >),-1,298752,(char*)NULL,G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR,G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR),sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::FitResult> >),-1,297216,(char*)NULL,G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR,G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLFitResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR),sizeof(map<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult>,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> > > >),-1,298752,(char*)NULL,G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR,G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR),sizeof(pair<unsigned int,RAT::DS::FitClassifierCollection<RAT::DS::ClassifierResult> >),-1,297216,(char*)NULL,G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR,G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLFitClassifierCollectionlERATcLcLDScLcLClassifierResultgRsPgRsPgRsPgRcLcLiteratorcOboolgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLDigitisercOallocatorlERATcLcLDScLcLDigitisergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLTrigHeader),sizeof(RAT::DS::TrigHeader),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLTrigHeader,G__setup_memfuncRATcLcLDScLcLTrigHeader);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPshortcOunsignedsPshortcOlesslEunsignedsPshortgRcOallocatorlEpairlEconstsPunsignedsPshortcOunsignedsPshortgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLHeaderInfo),sizeof(RAT::DS::HeaderInfo),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLHeaderInfo,G__setup_memfuncRATcLcLDScLcLHeaderInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR),sizeof(vector<RAT::DS::ECAHeader,allocator<RAT::DS::ECAHeader> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLECAHeadercOallocatorlERATcLcLDScLcLECAHeadergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR),sizeof(vector<RAT::DS::TrigHeader,allocator<RAT::DS::TrigHeader> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLTrigHeadercOallocatorlERATcLcLDScLcLTrigHeadergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMetaDB),sizeof(RAT::DS::MetaDB),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMetaDB,G__setup_memfuncRATcLcLDScLcLMetaDB);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEstringcOstringgR),sizeof(pair<string,string>),-1,297216,(char*)NULL,G__setup_memvarpairlEstringcOstringgR,G__setup_memfuncpairlEstringcOstringgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlEpairlEstringcOstringgRcOallocatorlEpairlEstringcOstringgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLRun),sizeof(RAT::DS::Run),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLRun,G__setup_memfuncRATcLcLDScLcLRun);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMeta),sizeof(RAT::DS::Meta),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMeta,G__setup_memfuncRATcLcLDScLcLMeta);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLMetaHelper);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR),sizeof(vector<RAT::DS::MetaDB,allocator<RAT::DS::MetaDB> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMetaDBcOallocatorlERATcLcLDScLcLMetaDBgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCParticle),sizeof(RAT::DS::MCParticle),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCParticle,G__setup_memfuncRATcLcLDScLcLMCParticle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStep),sizeof(RAT::DS::MCTrackStep),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCTrackStep,G__setup_memfuncRATcLcLDScLcLMCTrackStep);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEStatus);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCTrackStepcLcLEProcess);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCTrack),sizeof(RAT::DS::MCTrack),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCTrack,G__setup_memfuncRATcLcLDScLcLMCTrack);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCTrackcLcLESummaryFlag);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_setlEunsignedsPlongcOlesslEunsignedsPlonggRcOallocatorlEunsignedsPlonggRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR),sizeof(vector<RAT::DS::MCTrackStep,allocator<RAT::DS::MCTrackStep> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackStepcOallocatorlERATcLcLDScLcLMCTrackStepgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPhoton),sizeof(RAT::DS::MCPhoton),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCPhoton,G__setup_memfuncRATcLcLDScLcLMCPhoton);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPhotoncLcLEPhotonFate);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPE),sizeof(RAT::DS::MCPE),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCPE,G__setup_memfuncRATcLcLDScLcLMCPE);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhotonHistory);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPEcLcLPhHistoryStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCPMT),sizeof(RAT::DS::MCPMT),-1,323840,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCPMT,G__setup_memfuncRATcLcLDScLcLMCPMT);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR),sizeof(vector<RAT::DS::MCPhoton,allocator<RAT::DS::MCPhoton> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPhotoncOallocatorlERATcLcLDScLcLMCPhotongRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR),sizeof(vector<RAT::DS::MCPE,allocator<RAT::DS::MCPE> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPEcOallocatorlERATcLcLDScLcLMCPEgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMC),sizeof(RAT::DS::MC),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLMC,G__setup_memfuncRATcLcLDScLcLMC);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR),sizeof(vector<RAT::DS::MCParticle,allocator<RAT::DS::MCParticle> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCParticlecOallocatorlERATcLcLDScLcLMCParticlegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR),sizeof(vector<RAT::DS::MCTrack,allocator<RAT::DS::MCTrack> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCTrackcOallocatorlERATcLcLDScLcLMCTrackgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR),sizeof(vector<RAT::DS::MCPMT,allocator<RAT::DS::MCPMT> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCPMTcOallocatorlERATcLcLDScLcLMCPMTgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLMCEV),sizeof(RAT::DS::MCEV),-1,292096,(char*)NULL,G__setup_memvarRATcLcLDScLcLMCEV,G__setup_memfuncRATcLcLDScLcLMCEV);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLEntry),sizeof(RAT::DS::Entry),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLEntry,G__setup_memfuncRATcLcLDScLcLEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR),sizeof(vector<RAT::DS::MC,allocator<RAT::DS::MC> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCcOallocatorlERATcLcLDScLcLMCgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR),sizeof(vector<RAT::DS::MCEV,allocator<RAT::DS::MCEV> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLMCEVcOallocatorlERATcLcLDScLcLMCEVgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR),sizeof(vector<RAT::DS::EV,allocator<RAT::DS::EV> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLEVcOallocatorlERATcLcLDScLcLEVgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR),sizeof(vector<RAT::DS::HeaderInfo,allocator<RAT::DS::HeaderInfo> >),-1,298752,(char*)NULL,G__setup_memvarvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR,G__setup_memfuncvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDScLcLHeaderInfocOallocatorlERATcLcLDScLcLHeaderInfogRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLSOCPMT),sizeof(RAT::DS::SOCPMT),-1,323840,(char*)NULL,G__setup_memvarRATcLcLDScLcLSOCPMT,G__setup_memfuncRATcLcLDScLcLSOCPMT);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLSOCPMTcLcLEPeakFindStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDScLcLSOC),sizeof(RAT::DS::SOC),-1,291072,(char*)NULL,G__setup_memvarRATcLcLDScLcLSOC,G__setup_memfuncRATcLcLDScLcLSOC);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR),sizeof(map<unsigned int,RAT::DS::SOCPMT,less<unsigned int>,allocator<pair<const unsigned int,RAT::DS::SOCPMT> > >),-1,298752,(char*)NULL,G__setup_memvarmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR,G__setup_memfuncmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR),sizeof(pair<unsigned int,RAT::DS::SOCPMT>),-1,297216,(char*)NULL,G__setup_memvarpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR,G__setup_memfuncpairlEunsignedsPintcORATcLcLDScLcLSOCPMTgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEunsignedsPintcORATcLcLDScLcLSOCPMTcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcORATcLcLDScLcLSOCPMTgRsPgRsPgRcLcLiteratorcOboolgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcORATcLcLDScLcLSOCcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORATcLcLDScLcLSOCgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBits),sizeof(RAT::DU::DataCleaningBits),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLDataCleaningBits,G__setup_memfuncRATcLcLDUcLcLDataCleaningBits);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLDataCleaningBitscLcLBit);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOunsignedsPlongcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOunsignedsPlonggRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEunsignedsPlongcOstringcOlesslEunsignedsPlonggRcOallocatorlEpairlEconstsPunsignedsPlongcOstringgRsPgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBits),sizeof(RAT::DU::DataQualityBits),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLDataQualityBits,G__setup_memfuncRATcLcLDUcLcLDataQualityBits);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLDataQualityBitscLcLBit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatus),sizeof(RAT::DU::ChanSWStatus),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLChanSWStatus,G__setup_memfuncRATcLcLDUcLcLChanSWStatus);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLChanSWStatuscLcLBit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLTrigBits),sizeof(RAT::DU::TrigBits),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLTrigBits,G__setup_memfuncRATcLcLDUcLcLTrigBits);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLTrigBitscLcLdA);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TChain);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLDSReader),sizeof(RAT::DU::DSReader),-1,62464,(char*)NULL,G__setup_memvarRATcLcLDUcLcLDSReader,G__setup_memfuncRATcLcLDUcLcLDSReader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLEffectiveVelocity),sizeof(RAT::DU::EffectiveVelocity),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLEffectiveVelocity,G__setup_memfuncRATcLcLDUcLcLEffectiveVelocity);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_complexlEdoublegR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEboolcOunsignedsPintgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_stlplus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBTable),sizeof(RAT::DBTable),-1,296192,(char*)NULL,G__setup_memvarRATcLcLDBTable,G__setup_memfuncRATcLcLDBTable);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBTablecLcLFieldType);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_stlpluscLcLhashlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEstlpluscLcLhash_iteratorlEstringcORATcLcLDBTablecLcLFieldTypecORATcLcLpyhashcOequal_tolEstringgRcOpairlEconstsPstringcORATcLcLDBTablecLcLFieldTypegRsPgRcOboolgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDB),sizeof(RAT::DB),-1,263424,(char*)NULL,G__setup_memvarRATcLcLDB,G__setup_memfuncRATcLcLDB);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBLink),sizeof(RAT::DBLink),-1,295936,(char*)NULL,G__setup_memvarRATcLcLDBLink,G__setup_memfuncRATcLcLDBLink);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLPgSQLBackend),sizeof(RAT::PgSQLBackend),-1,263424,(char*)NULL,G__setup_memvarRATcLcLPgSQLBackend,G__setup_memfuncRATcLcLPgSQLBackend);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBTableKey);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBTablegR),sizeof(simple_ptr_nocopy<RAT::DBTable>),-1,298752,(char*)NULL,G__setup_memvarsimple_ptr_nocopylERATcLcLDBTablegR,G__setup_memfuncsimple_ptr_nocopylERATcLcLDBTablegR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplERATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRcOlesslERATcLcLDBTableKeygRcOallocatorlEpairlEconstsPRATcLcLDBTableKeycOsimple_ptr_nocopylERATcLcLDBTablegRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_simple_ptr_nocopylERATcLcLDBLinkgR),sizeof(simple_ptr_nocopy<RAT::DBLink>),-1,298752,(char*)NULL,G__setup_memvarsimple_ptr_nocopylERATcLcLDBLinkgR,G__setup_memfuncsimple_ptr_nocopylERATcLcLDBLinkgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOsimple_ptr_nocopylERATcLcLDBLinkgRcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOsimple_ptr_nocopylERATcLcLDBLinkgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR),sizeof(vector<RAT::DBTable*,allocator<RAT::DBTable*> >),-1,36608,(char*)NULL,G__setup_memvarvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR,G__setup_memfuncvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablemUcOallocatorlERATcLcLDBTablemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEpairlEstringcOstringgRcOintcOlesslEpairlEstringcOstringgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOstringgRcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_listlERATcLcLDBLinkmUcOallocatorlERATcLcLDBLinkmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_setlERATcLcLDBTableKeycOlesslERATcLcLDBTableKeygRcOallocatorlERATcLcLDBTableKeygRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_dequelERATcLcLDBTableKeycOallocatorlERATcLcLDBTableKeygRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_TGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLGroupVelocity),sizeof(RAT::DU::GroupVelocity),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLGroupVelocity,G__setup_memfuncRATcLcLDUcLcLGroupVelocity);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLeLightPathType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLLightPathCalculator),sizeof(RAT::DU::LightPathCalculator),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLLightPathCalculator,G__setup_memfuncRATcLcLDUcLcLLightPathCalculator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplERATcLcLDUcLcLeLightPathTypecOstringcOlesslERATcLcLDUcLcLeLightPathTypegRcOallocatorlEpairlEconstsPRATcLcLDUcLcLeLightPathTypecOstringgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfo),sizeof(RAT::DU::PanelInfo),-1,28672,(char*)NULL,G__setup_memvarRATcLcLDUcLcLPanelInfo,G__setup_memfuncRATcLcLDUcLcLPanelInfo);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPanelInfocLcLEPanelType);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPanelInfocLcLEPanelTypecOallocatorlERATcLcLDUcLcLPanelInfocLcLEPanelTypegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLChanHWStatus),sizeof(RAT::DU::ChanHWStatus),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLChanHWStatus,G__setup_memfuncRATcLcLDUcLcLChanHWStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatus),sizeof(RAT::DU::PMTCalStatus),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLPMTCalStatus,G__setup_memfuncRATcLcLDUcLcLPMTCalStatus);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPMTCalStatuscLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLReactorNuOsc),sizeof(RAT::DU::ReactorNuOsc),-1,0,(char*)NULL,G__setup_memvarRATcLcLDUcLcLReactorNuOsc,G__setup_memfuncRATcLcLDUcLcLReactorNuOsc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLShadowingCalculator),sizeof(RAT::DU::ShadowingCalculator),-1,0,(char*)NULL,G__setup_memvarRATcLcLDUcLcLShadowingCalculator,G__setup_memfuncRATcLcLDUcLcLShadowingCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLSegmentor),sizeof(RAT::DU::Segmentor),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLSegmentor,G__setup_memfuncRATcLcLDUcLcLSegmentor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLSOCReader),sizeof(RAT::DU::SOCReader),-1,62464,(char*)NULL,G__setup_memvarRATcLcLDUcLcLSOCReader,G__setup_memfuncRATcLcLDUcLcLSOCReader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLReconCorrector),sizeof(RAT::DU::ReconCorrector),-1,262400,(char*)NULL,G__setup_memvarRATcLcLDUcLcLReconCorrector,G__setup_memfuncRATcLcLDUcLcLReconCorrector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLReconCalibrator),sizeof(RAT::DU::ReconCalibrator),-1,262400,(char*)NULL,G__setup_memvarRATcLcLDUcLcLReconCalibrator,G__setup_memfuncRATcLcLDUcLcLReconCalibrator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLFitterPMT),sizeof(RAT::FitterPMT),-1,296192,(char*)NULL,G__setup_memvarRATcLcLFitterPMT,G__setup_memfuncRATcLcLFitterPMT);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLTimeResidualCalculator),sizeof(RAT::DU::TimeResidualCalculator),-1,28928,(char*)NULL,G__setup_memvarRATcLcLDUcLcLTimeResidualCalculator,G__setup_memfuncRATcLcLDUcLcLTimeResidualCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLUtility),sizeof(RAT::DU::Utility),-1,64256,(char*)NULL,G__setup_memvarRATcLcLDUcLcLUtility,G__setup_memfuncRATcLcLDUcLcLUtility);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLTrackNode),sizeof(RAT::TrackNode),-1,32000,(char*)NULL,G__setup_memvarRATcLcLTrackNode,G__setup_memfuncRATcLcLTrackNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR),sizeof(vector<RAT::TrackNode*,allocator<RAT::TrackNode*> >),-1,36608,(char*)NULL,G__setup_memvarvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR,G__setup_memfuncvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodemUcOallocatorlERATcLcLTrackNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLTrackTest);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_unary_functionlERATcLcLTrackNodemUcOboolgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLTrackCursor),sizeof(RAT::TrackCursor),-1,32768,(char*)NULL,G__setup_memvarRATcLcLTrackCursor,G__setup_memfuncRATcLcLTrackCursor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLTrackNav),sizeof(RAT::TrackNav),-1,32768,(char*)NULL,G__setup_memvarRATcLcLTrackNav,G__setup_memfuncRATcLcLTrackNav);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEintcORATcLcLTrackNodemUcOlesslEintgRcOallocatorlEpairlEconstsPintcORATcLcLTrackNodemUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pg_conn);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pg_result);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pgNotify);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBCommandLoader),sizeof(RAT::DBCommandLoader),-1,262144,(char*)NULL,G__setup_memvarRATcLcLDBCommandLoader,G__setup_memfuncRATcLcLDBCommandLoader);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_dequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_stacklERATcLcLTokenizercOdequelERATcLcLTokenizercOallocatorlERATcLcLTokenizergRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBTextLoader),sizeof(RAT::DBTextLoader),-1,262144,(char*)NULL,G__setup_memvarRATcLcLDBTextLoader,G__setup_memfuncRATcLcLDBTextLoader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDBJsonLoader),sizeof(RAT::DBJsonLoader),-1,262144,(char*)NULL,G__setup_memvarRATcLcLDBJsonLoader,G__setup_memfuncRATcLcLDBJsonLoader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLHTTPDownloader),sizeof(RAT::HTTPDownloader),-1,263424,(char*)NULL,G__setup_memvarRATcLcLHTTPDownloader,G__setup_memfuncRATcLcLHTTPDownloader);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLMetaInformation),sizeof(RAT::MetaInformation),-1,295168,(char*)NULL,G__setup_memvarRATcLcLMetaInformation,G__setup_memfuncRATcLcLMetaInformation);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_PmtEventRecord),sizeof(PmtEventRecord),-1,131072,(char*)NULL,G__setup_memvarPmtEventRecord,G__setup_memfuncPmtEventRecord);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RunRecord),sizeof(RunRecord),-1,131072,(char*)NULL,G__setup_memvarRunRecord,G__setup_memfuncRunRecord);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_TriggerInfo),sizeof(TriggerInfo),-1,131072,(char*)NULL,G__setup_memvarTriggerInfo,G__setup_memfuncTriggerInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_EpedRecord),sizeof(EpedRecord),-1,131072,(char*)NULL,G__setup_memvarEpedRecord,G__setup_memfuncEpedRecord);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdab),0,-1,0,(char*)NULL,G__setup_memvarratzdab,G__setup_memfuncratzdab);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLunpack),0,-1,0,(char*)NULL,G__setup_memvarratzdabcLcLunpack,G__setup_memfuncratzdabcLcLunpack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLpack),0,-1,0,(char*)NULL,G__setup_memvarratzdabcLcLpack,G__setup_memfuncratzdabcLcLpack);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLunknown_record_error),sizeof(ratzdab::unknown_record_error),-1,131072,(char*)NULL,G__setup_memvarratzdabcLcLunknown_record_error,G__setup_memfuncratzdabcLcLunknown_record_error);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_PZdabFile),sizeof(PZdabFile),-1,1280,(char*)NULL,G__setup_memvarPZdabFile,G__setup_memfuncPZdabFile);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_nZDAB);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLzdabfile),sizeof(ratzdab::zdabfile),-1,164864,(char*)NULL,G__setup_memvarratzdabcLcLzdabfile,G__setup_memfuncratzdabcLcLzdabfile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLzdabfilecLcLzdab_file_read_error),sizeof(ratzdab::zdabfile::zdab_file_read_error),-1,131072,(char*)NULL,G__setup_memvarratzdabcLcLzdabfilecLcLzdab_file_read_error,G__setup_memfuncratzdabcLcLzdabfilecLcLzdab_file_read_error);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_ManipRopeStatus),sizeof(ManipRopeStatus),-1,131072,(char*)NULL,G__setup_memvarManipRopeStatus,G__setup_memfuncManipRopeStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_MTCReadoutData),sizeof(MTCReadoutData),-1,131072,(char*)NULL,G__setup_memvarMTCReadoutData,G__setup_memfuncMTCReadoutData);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_ratzdabcLcLPMTCal);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_PZdabFilecLcLzdab_file_unexpected_eof);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLutil),0,-1,0,(char*)NULL,G__setup_memvarRATcLcLutil,G__setup_memfuncRATcLcLutil);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_CLHEP);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_CLHEPcLcLHep3Vector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLEnergySystematics),sizeof(RAT::DU::EnergySystematics),-1,323584,(char*)NULL,G__setup_memvarRATcLcLDUcLcLEnergySystematics,G__setup_memfuncRATcLcLDUcLcLEnergySystematics);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLDUcLcLPoint3D),sizeof(RAT::DU::Point3D),-1,64256,(char*)NULL,G__setup_memvarRATcLcLDUcLcLPoint3D,G__setup_memfuncRATcLcLDUcLcLPoint3D);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLP);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPath),sizeof(RAT::LP::LightPath),-1,295168,(char*)NULL,G__setup_memvarRATcLcLLPcLcLLightPath,G__setup_memfuncRATcLcLLPcLcLLightPath);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPathcLcLRegionType);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDUcLcLPoint3DcOallocatorlERATcLcLDUcLcLPoint3DgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLLPcLcLLightPathcLcLRegionTypecOallocatorlERATcLcLLPcLcLLightPathcLcLRegionTypegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPathFitter),sizeof(RAT::LP::LightPathFitter),-1,263426,(char*)NULL,G__setup_memvarRATcLcLLPcLcLLightPathFitter,G__setup_memfuncRATcLcLLPcLcLLightPathFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightFitter),sizeof(RAT::LP::LightPathStraightFitter),-1,262400,(char*)NULL,G__setup_memvarRATcLcLLPcLcLLightPathStraightFitter,G__setup_memfuncRATcLcLLPcLcLLightPathStraightFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScint),sizeof(RAT::LP::LightPathStraightScint),-1,262400,(char*)NULL,G__setup_memvarRATcLcLLPcLcLLightPathStraightScint,G__setup_memfuncRATcLcLLPcLcLLightPathStraightScint);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_RATcLcLLPcLcLLightPathStraightScintWater),sizeof(RAT::LP::LightPathStraightScintWater),-1,262400,(char*)NULL,G__setup_memvarRATcLcLLPcLcLLightPathStraightScintWater,G__setup_memfuncRATcLcLLPcLcLLightPathStraightScintWater);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_allocatorlEpairlEconstsPstringcOstringgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),sizeof(map<string,string,less<string>,allocator<pair<const string,string> > >),-1,298752,(char*)NULL,G__setup_memvarmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR,G__setup_memfuncmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_pairlEmaplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiteratorcOboolgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR),sizeof(vector<RAT::TrackNode,allocator<RAT::TrackNode> >),-1,36608,(char*)NULL,G__setup_memvarvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR,G__setup_memfuncvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLTrackNodecOallocatorlERATcLcLTrackNodegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR),sizeof(vector<RAT::DBTable,allocator<RAT::DBTable> >),-1,36608,(char*)NULL,G__setup_memvarvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR,G__setup_memfuncvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgR);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_vectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__RAT_DictLN_reverse_iteratorlEvectorlERATcLcLDBTablecOallocatorlERATcLcLDBTablegRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupRAT_Dict(void) {
  G__check_setup_version(30051515,"G__cpp_setupRAT_Dict()");
  G__set_cpp_environmentRAT_Dict();
  G__cpp_setup_tagtableRAT_Dict();

  G__cpp_setup_inheritanceRAT_Dict();

  G__cpp_setup_typetableRAT_Dict();

  G__cpp_setup_memvarRAT_Dict();

  G__cpp_setup_memfuncRAT_Dict();
  G__cpp_setup_globalRAT_Dict();
  G__cpp_setup_funcRAT_Dict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncRAT_Dict();
  return;
}
class G__cpp_setup_initRAT_Dict {
  public:
    G__cpp_setup_initRAT_Dict() { G__add_setup_func("RAT_Dict",(G__incsetup)(&G__cpp_setupRAT_Dict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initRAT_Dict() { G__remove_setup_func("RAT_Dict"); }
};
G__cpp_setup_initRAT_Dict G__cpp_setup_initializerRAT_Dict;