//
// File generated by /usr/local/bin/rootcint at Mon May 17 09:05:01 2010

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

#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 "HANDDict.h"

#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void THaPlane_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaPlane(void *p);
   static void deleteArray_THaPlane(void *p);
   static void destruct_THaPlane(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaPlane*)
   {
      ::THaPlane *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaPlane >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaPlane", ::THaPlane::Class_Version(), "THaPlane.h", 14,
                  typeid(::THaPlane), DefineBehavior(ptr, ptr),
                  &::THaPlane::Dictionary, isa_proxy, 4,
                  sizeof(::THaPlane) );
      instance.SetDelete(&delete_THaPlane);
      instance.SetDeleteArray(&deleteArray_THaPlane);
      instance.SetDestructor(&destruct_THaPlane);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaPlane*)
   {
      return GenerateInitInstanceLocal((::THaPlane*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaPlane*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaNAScintHit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_THaNAScintHit(void *p = 0);
   static void *newArray_THaNAScintHit(Long_t size, void *p);
   static void delete_THaNAScintHit(void *p);
   static void deleteArray_THaNAScintHit(void *p);
   static void destruct_THaNAScintHit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaNAScintHit*)
   {
      ::THaNAScintHit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaNAScintHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaNAScintHit", ::THaNAScintHit::Class_Version(), "THaNAScintHit.h", 13,
                  typeid(::THaNAScintHit), DefineBehavior(ptr, ptr),
                  &::THaNAScintHit::Dictionary, isa_proxy, 4,
                  sizeof(::THaNAScintHit) );
      instance.SetNew(&new_THaNAScintHit);
      instance.SetNewArray(&newArray_THaNAScintHit);
      instance.SetDelete(&delete_THaNAScintHit);
      instance.SetDeleteArray(&deleteArray_THaNAScintHit);
      instance.SetDestructor(&destruct_THaNAScintHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaNAScintHit*)
   {
      return GenerateInitInstanceLocal((::THaNAScintHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaNAScintHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaScintillatorPlane_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaScintillatorPlane(void *p);
   static void deleteArray_THaScintillatorPlane(void *p);
   static void destruct_THaScintillatorPlane(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaScintillatorPlane*)
   {
      ::THaScintillatorPlane *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaScintillatorPlane >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaScintillatorPlane", ::THaScintillatorPlane::Class_Version(), "THaScintillatorPlane.h", 40,
                  typeid(::THaScintillatorPlane), DefineBehavior(ptr, ptr),
                  &::THaScintillatorPlane::Dictionary, isa_proxy, 4,
                  sizeof(::THaScintillatorPlane) );
      instance.SetDelete(&delete_THaScintillatorPlane);
      instance.SetDeleteArray(&deleteArray_THaScintillatorPlane);
      instance.SetDestructor(&destruct_THaScintillatorPlane);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaScintillatorPlane*)
   {
      return GenerateInitInstanceLocal((::THaScintillatorPlane*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaScintillatorPlane*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaNDTrack_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_THaNDTrack(void *p = 0);
   static void *newArray_THaNDTrack(Long_t size, void *p);
   static void delete_THaNDTrack(void *p);
   static void deleteArray_THaNDTrack(void *p);
   static void destruct_THaNDTrack(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaNDTrack*)
   {
      ::THaNDTrack *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaNDTrack >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaNDTrack", ::THaNDTrack::Class_Version(), "THaNDTrack.h", 15,
                  typeid(::THaNDTrack), DefineBehavior(ptr, ptr),
                  &::THaNDTrack::Dictionary, isa_proxy, 4,
                  sizeof(::THaNDTrack) );
      instance.SetNew(&new_THaNDTrack);
      instance.SetNewArray(&newArray_THaNDTrack);
      instance.SetDelete(&delete_THaNDTrack);
      instance.SetDeleteArray(&deleteArray_THaNDTrack);
      instance.SetDestructor(&destruct_THaNDTrack);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaNDTrack*)
   {
      return GenerateInitInstanceLocal((::THaNDTrack*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaNDTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaNeutronDetector_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaNeutronDetector(void *p);
   static void deleteArray_THaNeutronDetector(void *p);
   static void destruct_THaNeutronDetector(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaNeutronDetector*)
   {
      ::THaNeutronDetector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaNeutronDetector >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaNeutronDetector", ::THaNeutronDetector::Class_Version(), "THaNeutronDetector.h", 18,
                  typeid(::THaNeutronDetector), DefineBehavior(ptr, ptr),
                  &::THaNeutronDetector::Dictionary, isa_proxy, 4,
                  sizeof(::THaNeutronDetector) );
      instance.SetDelete(&delete_THaNeutronDetector);
      instance.SetDeleteArray(&deleteArray_THaNeutronDetector);
      instance.SetDestructor(&destruct_THaNeutronDetector);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaNeutronDetector*)
   {
      return GenerateInitInstanceLocal((::THaNeutronDetector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaNeutronDetector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaVeto_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaVeto(void *p);
   static void deleteArray_THaVeto(void *p);
   static void destruct_THaVeto(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaVeto*)
   {
      ::THaVeto *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaVeto >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaVeto", ::THaVeto::Class_Version(), "THaVeto.h", 6,
                  typeid(::THaVeto), DefineBehavior(ptr, ptr),
                  &::THaVeto::Dictionary, isa_proxy, 4,
                  sizeof(::THaVeto) );
      instance.SetDelete(&delete_THaVeto);
      instance.SetDeleteArray(&deleteArray_THaVeto);
      instance.SetDestructor(&destruct_THaVeto);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaVeto*)
   {
      return GenerateInitInstanceLocal((::THaVeto*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaVeto*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaNDNeutron_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_THaNDNeutron(void *p = 0);
   static void *newArray_THaNDNeutron(Long_t size, void *p);
   static void delete_THaNDNeutron(void *p);
   static void deleteArray_THaNDNeutron(void *p);
   static void destruct_THaNDNeutron(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaNDNeutron*)
   {
      ::THaNDNeutron *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaNDNeutron >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaNDNeutron", ::THaNDNeutron::Class_Version(), "THaNDNeutron.h", 17,
                  typeid(::THaNDNeutron), DefineBehavior(ptr, ptr),
                  &::THaNDNeutron::Dictionary, isa_proxy, 4,
                  sizeof(::THaNDNeutron) );
      instance.SetNew(&new_THaNDNeutron);
      instance.SetNewArray(&newArray_THaNDNeutron);
      instance.SetDelete(&delete_THaNDNeutron);
      instance.SetDeleteArray(&deleteArray_THaNDNeutron);
      instance.SetDestructor(&destruct_THaNDNeutron);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaNDNeutron*)
   {
      return GenerateInitInstanceLocal((::THaNDNeutron*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaNDNeutron*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaNA_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaNA(void *p);
   static void deleteArray_THaNA(void *p);
   static void destruct_THaNA(void *p);

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

namespace ROOT {
   void THaPaddle_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void delete_THaPaddle(void *p);
   static void deleteArray_THaPaddle(void *p);
   static void destruct_THaPaddle(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaPaddle*)
   {
      ::THaPaddle *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaPaddle >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaPaddle", ::THaPaddle::Class_Version(), "THaPaddle.h", 12,
                  typeid(::THaPaddle), DefineBehavior(ptr, ptr),
                  &::THaPaddle::Dictionary, isa_proxy, 4,
                  sizeof(::THaPaddle) );
      instance.SetDelete(&delete_THaPaddle);
      instance.SetDeleteArray(&deleteArray_THaPaddle);
      instance.SetDestructor(&destruct_THaPaddle);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaPaddle*)
   {
      return GenerateInitInstanceLocal((::THaPaddle*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaPaddle*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaPlaneHit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_THaPlaneHit(void *p = 0);
   static void *newArray_THaPlaneHit(Long_t size, void *p);
   static void delete_THaPlaneHit(void *p);
   static void deleteArray_THaPlaneHit(void *p);
   static void destruct_THaPlaneHit(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaPlaneHit*)
   {
      ::THaPlaneHit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaPlaneHit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaPlaneHit", ::THaPlaneHit::Class_Version(), "THaPlaneHit.h", 17,
                  typeid(::THaPlaneHit), DefineBehavior(ptr, ptr),
                  &::THaPlaneHit::Dictionary, isa_proxy, 4,
                  sizeof(::THaPlaneHit) );
      instance.SetNew(&new_THaPlaneHit);
      instance.SetNewArray(&newArray_THaPlaneHit);
      instance.SetDelete(&delete_THaPlaneHit);
      instance.SetDeleteArray(&deleteArray_THaPlaneHit);
      instance.SetDestructor(&destruct_THaPlaneHit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaPlaneHit*)
   {
      return GenerateInitInstanceLocal((::THaPlaneHit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaPlaneHit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

//______________________________________________________________________________
TClass *THaPlane::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaPlane::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPlane*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaPlane::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPlane*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaPlane::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaPlane*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaNAScintHit::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaNAScintHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNAScintHit*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaNAScintHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNAScintHit*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaNAScintHit::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaNAScintHit*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaScintillatorPlane::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaScintillatorPlane::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaScintillatorPlane*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaScintillatorPlane::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaScintillatorPlane*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaScintillatorPlane::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaScintillatorPlane*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaNDTrack::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaNDTrack::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNDTrack*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaNDTrack::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNDTrack*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaNDTrack::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaNDTrack*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaNeutronDetector::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaNeutronDetector::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNeutronDetector*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaNeutronDetector::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNeutronDetector*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaNeutronDetector::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaNeutronDetector*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaVeto::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaVeto::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaVeto*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaVeto::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaVeto*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaVeto::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaVeto*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaNDNeutron::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaNDNeutron::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNDNeutron*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaNDNeutron::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNDNeutron*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaNDNeutron::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaNDNeutron*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaNA::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaNA::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNA*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaNA::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaNA*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaNA::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaNA*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaPaddle::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaPaddle::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPaddle*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaPaddle::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPaddle*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaPaddle::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaPaddle*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *THaPlaneHit::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *THaPlaneHit::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPlaneHit*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int THaPlaneHit::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaPlaneHit*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *THaPlaneHit::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaPlaneHit*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
void THaScintillatorPlane::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaScintillatorPlane.

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

//______________________________________________________________________________
void THaScintillatorPlane::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaScintillatorPlane.
      TClass *R__cl = ::THaScintillatorPlane::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNPaddlesHit", &fNPaddlesHit);
      R__insp.Inspect(R__cl, R__parent, "*fFirstChan", &fFirstChan);
      R__insp.Inspect(R__cl, R__parent, "*fHits", &fHits);
      R__insp.Inspect(R__cl, R__parent, "fLTNhit", &fLTNhit);
      R__insp.Inspect(R__cl, R__parent, "fRTNhit", &fRTNhit);
      R__insp.Inspect(R__cl, R__parent, "fLANhit", &fLANhit);
      R__insp.Inspect(R__cl, R__parent, "fRANhit", &fRANhit);
      R__insp.Inspect(R__cl, R__parent, "*fLT", &fLT);
      R__insp.Inspect(R__cl, R__parent, "*fRT", &fRT);
      R__insp.Inspect(R__cl, R__parent, "*fLToff", &fLToff);
      R__insp.Inspect(R__cl, R__parent, "*fRToff", &fRToff);
      R__insp.Inspect(R__cl, R__parent, "*fLAped", &fLAped);
      R__insp.Inspect(R__cl, R__parent, "*fRAped", &fRAped);
      R__insp.Inspect(R__cl, R__parent, "*fLAgain", &fLAgain);
      R__insp.Inspect(R__cl, R__parent, "*fRAgain", &fRAgain);
      R__insp.Inspect(R__cl, R__parent, "*fLT_c", &fLT_c);
      R__insp.Inspect(R__cl, R__parent, "*fRT_c", &fRT_c);
      R__insp.Inspect(R__cl, R__parent, "*fLA", &fLA);
      R__insp.Inspect(R__cl, R__parent, "*fRA", &fRA);
      R__insp.Inspect(R__cl, R__parent, "*fLA_c", &fLA_c);
      R__insp.Inspect(R__cl, R__parent, "*fRA_c", &fRA_c);
      R__insp.Inspect(R__cl, R__parent, "*fTDiff", &fTDiff);
      R__insp.Inspect(R__cl, R__parent, "*fYPos", &fYPos);
      R__insp.Inspect(R__cl, R__parent, "*fYBar", &fYBar);
      R__insp.Inspect(R__cl, R__parent, "*fXBar", &fXBar);
      R__insp.Inspect(R__cl, R__parent, "*fZBar", &fZBar);
      R__insp.Inspect(R__cl, R__parent, "*fDist", &fDist);
      R__insp.Inspect(R__cl, R__parent, "*fTOFOffset", &fTOFOffset);
      R__insp.Inspect(R__cl, R__parent, "*fTOFScale", &fTOFScale);
      R__insp.Inspect(R__cl, R__parent, "*fYOffset", &fYOffset);
      R__insp.Inspect(R__cl, R__parent, "*fYScale", &fYScale);
      R__insp.Inspect(R__cl, R__parent, "*fTOF", &fTOF);
      R__insp.Inspect(R__cl, R__parent, "*fIsHit", &fIsHit);
      R__insp.Inspect(R__cl, R__parent, "*fNLHits", &fNLHits);
      R__insp.Inspect(R__cl, R__parent, "*fNRHits", &fNRHits);
      R__insp.Inspect(R__cl, R__parent, "*fIBlockingBarMin", &fIBlockingBarMin);
      R__insp.Inspect(R__cl, R__parent, "*fIBlockingBarMax", &fIBlockingBarMax);
      R__insp.Inspect(R__cl, R__parent, "*fMultiHits", &fMultiHits);
      R__insp.Inspect(R__cl, R__parent, "fDataDest[2]", fDataDest);
      THaPlane::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaScintillatorPlane(void *p) {
      delete ((::THaScintillatorPlane*)p);
   }
   static void deleteArray_THaScintillatorPlane(void *p) {
      delete [] ((::THaScintillatorPlane*)p);
   }
   static void destruct_THaScintillatorPlane(void *p) {
      typedef ::THaScintillatorPlane current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaScintillatorPlane

//______________________________________________________________________________
void THaNeutronDetector::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaNeutronDetector.

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

//______________________________________________________________________________
void THaNeutronDetector::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaNeutronDetector.
      TClass *R__cl = ::THaNeutronDetector::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fPlane1", &fPlane1);
      R__insp.Inspect(R__cl, R__parent, "*fPlane2", &fPlane2);
      R__insp.Inspect(R__cl, R__parent, "*fPlane3", &fPlane3);
      R__insp.Inspect(R__cl, R__parent, "*fPlane4", &fPlane4);
      R__insp.Inspect(R__cl, R__parent, "fNPlanesHit", &fNPlanesHit);
      R__insp.Inspect(R__cl, R__parent, "*fNDTracks[20]", &fNDTracks);
      R__insp.Inspect(R__cl, R__parent, "fNTracks", &fNTracks);
      R__insp.Inspect(R__cl, R__parent, "fTheta[20]", fTheta);
      R__insp.Inspect(R__cl, R__parent, "fPhi[20]", fPhi);
      R__insp.Inspect(R__cl, R__parent, "fNHits[20]", fNHits);
      R__insp.Inspect(R__cl, R__parent, "fTOF[20]", fTOF);
      R__insp.Inspect(R__cl, R__parent, "fDist[20]", fDist);
      R__insp.Inspect(R__cl, R__parent, "fEnergyDeposit[20]", fEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fVetoHit[20]", fVetoHit);
      R__insp.Inspect(R__cl, R__parent, "fMinAngle[4]", fMinAngle);
      THaNonTrackingDetector::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaNeutronDetector(void *p) {
      delete ((::THaNeutronDetector*)p);
   }
   static void deleteArray_THaNeutronDetector(void *p) {
      delete [] ((::THaNeutronDetector*)p);
   }
   static void destruct_THaNeutronDetector(void *p) {
      typedef ::THaNeutronDetector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaNeutronDetector

//______________________________________________________________________________
void THaNA::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaNA.

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

//______________________________________________________________________________
void THaNA::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaNA.
      TClass *R__cl = ::THaNA::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fTracks", &fTracks);
      R__insp.Inspect(R__cl, R__parent, "*fwvTracks", &fwvTracks);
      R__insp.Inspect(R__cl, R__parent, "*fwovTracks", &fwovTracks);
      R__insp.Inspect(R__cl, R__parent, "*fNDTracks[20]", &fNDTracks);
      R__insp.Inspect(R__cl, R__parent, "fTheta[20]", fTheta);
      R__insp.Inspect(R__cl, R__parent, "fPhi[20]", fPhi);
      R__insp.Inspect(R__cl, R__parent, "fNHits[20]", fNHits);
      R__insp.Inspect(R__cl, R__parent, "fTOF[20]", fTOF);
      R__insp.Inspect(R__cl, R__parent, "fDist[20]", fDist);
      R__insp.Inspect(R__cl, R__parent, "fEnergyDeposit[20]", fEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fFirstHitPaddle[20]", fFirstHitPaddle);
      R__insp.Inspect(R__cl, R__parent, "fFirstHitPlane[20]", fFirstHitPlane);
      R__insp.Inspect(R__cl, R__parent, "*fNDwvTracks[20]", &fNDwvTracks);
      R__insp.Inspect(R__cl, R__parent, "fwvTheta[20]", fwvTheta);
      R__insp.Inspect(R__cl, R__parent, "fwvPhi[20]", fwvPhi);
      R__insp.Inspect(R__cl, R__parent, "fwvNHits[20]", fwvNHits);
      R__insp.Inspect(R__cl, R__parent, "fwvTOF[20]", fwvTOF);
      R__insp.Inspect(R__cl, R__parent, "fwvEnergyDeposit[20]", fwvEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fLeftIsHit[20]", fLeftIsHit);
      R__insp.Inspect(R__cl, R__parent, "fRightIsHit[20]", fRightIsHit);
      R__insp.Inspect(R__cl, R__parent, "*fNDwovTracks[20]", &fNDwovTracks);
      R__insp.Inspect(R__cl, R__parent, "fwovTheta[20]", fwovTheta);
      R__insp.Inspect(R__cl, R__parent, "fwovPhi[20]", fwovPhi);
      R__insp.Inspect(R__cl, R__parent, "fwovNHits[20]", fwovNHits);
      R__insp.Inspect(R__cl, R__parent, "fwovTOF[20]", fwovTOF);
      R__insp.Inspect(R__cl, R__parent, "fwovEnergyDeposit[20]", fwovEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fThetaGeo", &fThetaGeo);
      R__insp.Inspect(R__cl, R__parent, "fPhiGeo", &fPhiGeo);
      R__insp.Inspect(R__cl, R__parent, "fThetaSph", &fThetaSph);
      R__insp.Inspect(R__cl, R__parent, "fPhiSph", &fPhiSph);
      R__insp.Inspect(R__cl, R__parent, "fSinThGeo", &fSinThGeo);
      R__insp.Inspect(R__cl, R__parent, "fCosThGeo", &fCosThGeo);
      R__insp.Inspect(R__cl, R__parent, "fSinPhGeo", &fSinPhGeo);
      R__insp.Inspect(R__cl, R__parent, "fCosPhGeo", &fCosPhGeo);
      R__insp.Inspect(R__cl, R__parent, "fSinThSph", &fSinThSph);
      R__insp.Inspect(R__cl, R__parent, "fCosThSph", &fCosThSph);
      R__insp.Inspect(R__cl, R__parent, "fSinPhSph", &fSinPhSph);
      R__insp.Inspect(R__cl, R__parent, "fCosPhSph", &fCosPhSph);
      R__insp.Inspect(R__cl, R__parent, "fDistance", &fDistance);
      R__insp.Inspect(R__cl, R__parent, "fCoarseDone", &fCoarseDone);
      R__insp.Inspect(R__cl, R__parent, "*fNeutronDetector", &fNeutronDetector);
      R__insp.Inspect(R__cl, R__parent, "*fVeto", &fVeto);
      R__insp.Inspect(R__cl, R__parent, "fNTracks", &fNTracks);
      R__insp.Inspect(R__cl, R__parent, "fNwvTracks", &fNwvTracks);
      R__insp.Inspect(R__cl, R__parent, "fNwovTracks", &fNwovTracks);
      R__insp.Inspect(R__cl, R__parent, "fNNeutrons", &fNNeutrons);
      R__insp.Inspect(R__cl, R__parent, "fNTOF[50]", fNTOF);
      R__insp.Inspect(R__cl, R__parent, "fNPaddle[50]", fNPaddle);
      R__insp.Inspect(R__cl, R__parent, "fNPlane[50]", fNPlane);
      R__insp.Inspect(R__cl, R__parent, "fNTheta[50]", fNTheta);
      R__insp.Inspect(R__cl, R__parent, "fNPhi[50]", fNPhi);
      R__insp.Inspect(R__cl, R__parent, "fNEnergyDeposit[50]", fNEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fNDist[50]", fNDist);
      R__insp.Inspect(R__cl, R__parent, "*fNeutrons", &fNeutrons);
      R__insp.Inspect(R__cl, R__parent, "fVetoPairs[300][10]", fVetoPairs);
      R__insp.Inspect(R__cl, R__parent, "*fPlane1", &fPlane1);
      R__insp.Inspect(R__cl, R__parent, "*fPlane2", &fPlane2);
      R__insp.Inspect(R__cl, R__parent, "*fPlane3", &fPlane3);
      R__insp.Inspect(R__cl, R__parent, "*fPlane4", &fPlane4);
      R__insp.Inspect(R__cl, R__parent, "VetoTimeMin", &VetoTimeMin);
      R__insp.Inspect(R__cl, R__parent, "VetoTimeMax", &VetoTimeMax);
      THaApparatus::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaNA(void *p) {
      delete ((::THaNA*)p);
   }
   static void deleteArray_THaNA(void *p) {
      delete [] ((::THaNA*)p);
   }
   static void destruct_THaNA(void *p) {
      typedef ::THaNA current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaNA

//______________________________________________________________________________
void THaPlane::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaPlane.

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

//______________________________________________________________________________
void THaPlane::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaPlane.
      TClass *R__cl = ::THaPlane::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      THaNonTrackingDetector::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaPlane(void *p) {
      delete ((::THaPlane*)p);
   }
   static void deleteArray_THaPlane(void *p) {
      delete [] ((::THaPlane*)p);
   }
   static void destruct_THaPlane(void *p) {
      typedef ::THaPlane current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaPlane

//______________________________________________________________________________
void THaPlaneHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaPlaneHit.

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

//______________________________________________________________________________
void THaPlaneHit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaPlaneHit.
      TClass *R__cl = ::THaPlaneHit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fPaddle", &fPaddle);
      R__insp.Inspect(R__cl, R__parent, "*fPlane", &fPlane);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaPlaneHit(void *p) {
      return  p ? new(p) ::THaPlaneHit : new ::THaPlaneHit;
   }
   static void *newArray_THaPlaneHit(Long_t nElements, void *p) {
      return p ? new(p) ::THaPlaneHit[nElements] : new ::THaPlaneHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaPlaneHit(void *p) {
      delete ((::THaPlaneHit*)p);
   }
   static void deleteArray_THaPlaneHit(void *p) {
      delete [] ((::THaPlaneHit*)p);
   }
   static void destruct_THaPlaneHit(void *p) {
      typedef ::THaPlaneHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaPlaneHit

//______________________________________________________________________________
void THaPaddle::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaPaddle.

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

//______________________________________________________________________________
void THaPaddle::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaPaddle.
      TClass *R__cl = ::THaPaddle::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPaddleNumber", &fPaddleNumber);
      R__insp.Inspect(R__cl, R__parent, "fX", &fX);
      R__insp.Inspect(R__cl, R__parent, "fY", &fY);
      R__insp.Inspect(R__cl, R__parent, "fZ", &fZ);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaPaddle(void *p) {
      delete ((::THaPaddle*)p);
   }
   static void deleteArray_THaPaddle(void *p) {
      delete [] ((::THaPaddle*)p);
   }
   static void destruct_THaPaddle(void *p) {
      typedef ::THaPaddle current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaPaddle

//______________________________________________________________________________
void THaNAScintHit::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaNAScintHit.

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

//______________________________________________________________________________
void THaNAScintHit::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaNAScintHit.
      TClass *R__cl = ::THaNAScintHit::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPaddleNumber", &fPaddleNumber);
      R__insp.Inspect(R__cl, R__parent, "fHitYPos", &fHitYPos);
      R__insp.Inspect(R__cl, R__parent, "fHitTOF", &fHitTOF);
      R__insp.Inspect(R__cl, R__parent, "fHitTheta", &fHitTheta);
      R__insp.Inspect(R__cl, R__parent, "fHitPhi", &fHitPhi);
      R__insp.Inspect(R__cl, R__parent, "fEnergyDeposit", &fEnergyDeposit);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaNAScintHit(void *p) {
      return  p ? new(p) ::THaNAScintHit : new ::THaNAScintHit;
   }
   static void *newArray_THaNAScintHit(Long_t nElements, void *p) {
      return p ? new(p) ::THaNAScintHit[nElements] : new ::THaNAScintHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaNAScintHit(void *p) {
      delete ((::THaNAScintHit*)p);
   }
   static void deleteArray_THaNAScintHit(void *p) {
      delete [] ((::THaNAScintHit*)p);
   }
   static void destruct_THaNAScintHit(void *p) {
      typedef ::THaNAScintHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaNAScintHit

//______________________________________________________________________________
void THaNDTrack::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaNDTrack.

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

//______________________________________________________________________________
void THaNDTrack::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaNDTrack.
      TClass *R__cl = ::THaNDTrack::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__parent, "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__parent, "fTOF", &fTOF);
      R__insp.Inspect(R__cl, R__parent, "fEnergyDeposit", &fEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fDist", &fDist);
      R__insp.Inspect(R__cl, R__parent, "fFirstHitPlane", &fFirstHitPlane);
      R__insp.Inspect(R__cl, R__parent, "fFirstHitPaddle", &fFirstHitPaddle);
      R__insp.Inspect(R__cl, R__parent, "fNHits", &fNHits);
      R__insp.Inspect(R__cl, R__parent, "*fHits[35]", &fHits);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaNDTrack(void *p) {
      return  p ? new(p) ::THaNDTrack : new ::THaNDTrack;
   }
   static void *newArray_THaNDTrack(Long_t nElements, void *p) {
      return p ? new(p) ::THaNDTrack[nElements] : new ::THaNDTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaNDTrack(void *p) {
      delete ((::THaNDTrack*)p);
   }
   static void deleteArray_THaNDTrack(void *p) {
      delete [] ((::THaNDTrack*)p);
   }
   static void destruct_THaNDTrack(void *p) {
      typedef ::THaNDTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaNDTrack

//______________________________________________________________________________
void THaNDNeutron::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaNDNeutron.

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

//______________________________________________________________________________
void THaNDNeutron::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaNDNeutron.
      TClass *R__cl = ::THaNDNeutron::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__parent, "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__parent, "fTOF", &fTOF);
      R__insp.Inspect(R__cl, R__parent, "fEnergyDeposit", &fEnergyDeposit);
      R__insp.Inspect(R__cl, R__parent, "fDistance", &fDistance);
      R__insp.Inspect(R__cl, R__parent, "fHitPlane", &fHitPlane);
      R__insp.Inspect(R__cl, R__parent, "fHitPaddle", &fHitPaddle);
      R__insp.Inspect(R__cl, R__parent, "*fHit", &fHit);
      R__insp.Inspect(R__cl, R__parent, "fCosine", &fCosine);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaNDNeutron(void *p) {
      return  p ? new(p) ::THaNDNeutron : new ::THaNDNeutron;
   }
   static void *newArray_THaNDNeutron(Long_t nElements, void *p) {
      return p ? new(p) ::THaNDNeutron[nElements] : new ::THaNDNeutron[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaNDNeutron(void *p) {
      delete ((::THaNDNeutron*)p);
   }
   static void deleteArray_THaNDNeutron(void *p) {
      delete [] ((::THaNDNeutron*)p);
   }
   static void destruct_THaNDNeutron(void *p) {
      typedef ::THaNDNeutron current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaNDNeutron

//______________________________________________________________________________
void THaVeto::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaVeto.

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

//______________________________________________________________________________
void THaVeto::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class THaVeto.
      TClass *R__cl = ::THaVeto::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fHitRegion", &fHitRegion);
      R__insp.Inspect(R__cl, R__parent, "fPaddleOverlap", &fPaddleOverlap);
      R__insp.Inspect(R__cl, R__parent, "fMinAngle", &fMinAngle);
      R__insp.Inspect(R__cl, R__parent, "fNegRegionLimit", &fNegRegionLimit);
      R__insp.Inspect(R__cl, R__parent, "fPosRegionLimit", &fPosRegionLimit);
      R__insp.Inspect(R__cl, R__parent, "*fLeftIsHit", &fLeftIsHit);
      R__insp.Inspect(R__cl, R__parent, "*fRightIsHit", &fRightIsHit);
      THaScintillatorPlane::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_THaVeto(void *p) {
      delete ((::THaVeto*)p);
   }
   static void deleteArray_THaVeto(void *p) {
      delete [] ((::THaVeto*)p);
   }
   static void destruct_THaVeto(void *p) {
      typedef ::THaVeto current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaVeto

/********************************************************
* HANDDict.cxx
* 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_tagtableHANDDict();

extern "C" void G__set_cpp_environmentHANDDict() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("THaNeutronDetector.h");
  G__add_compiledheader("THaNA.h");
  G__add_compiledheader("THaPlane.h");
  G__add_compiledheader("THaPlaneHit.h");
  G__add_compiledheader("THaPaddle.h");
  G__add_compiledheader("THaNAScintHit.h");
  G__add_compiledheader("THaScintillatorPlane.h");
  G__add_compiledheader("THaNDTrack.h");
  G__add_compiledheader("THaNDNeutron.h");
  G__add_compiledheader("THaVeto.h");
  G__cpp_reset_tagtableHANDDict();
}
#include <new>
extern "C" int G__cpp_dllrevHANDDict() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* THaPlane */
static int G__HANDDict_230_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaPlane::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlane::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaPlane::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaPlane::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPlane*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlane::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPlane::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlane::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_230_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPlane::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaPlane G__TTHaPlane;
static int G__HANDDict_230_0_18(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[] (THaPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaPlane*) (soff+(sizeof(THaPlane)*i)))->~G__TTHaPlane();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaPlane*) (soff))->~G__TTHaPlane();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaNAScintHit */
static int G__HANDDict_240_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNAScintHit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNAScintHit(
(Int_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) THaNAScintHit(
(Int_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]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNAScintHit(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) THaNAScintHit(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNAScintHit((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) THaNAScintHit((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNAScintHit((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THaNAScintHit((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNAScintHit[n];
       } else {
         p = new((void*) gvp) THaNAScintHit[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNAScintHit;
       } else {
         p = new((void*) gvp) THaNAScintHit;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNAScintHit*) G__getstructoffset())->GetPaddleNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNAScintHit*) G__getstructoffset())->GetHitYPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNAScintHit*) G__getstructoffset())->GetHitTOF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNAScintHit*) G__getstructoffset())->GetHitTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNAScintHit*) G__getstructoffset())->GetHitPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNAScintHit*) G__getstructoffset())->GetEnergyDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->SetPaddleNumber((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->SetYHitPos((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->SetHitTOF((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->SetEnergyDeposit((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->SetHitAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaNAScintHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNAScintHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaNAScintHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaNAScintHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNAScintHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNAScintHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNAScintHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNAScintHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_240_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNAScintHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__HANDDict_240_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THaNAScintHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THaNAScintHit(*(THaNAScintHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaNAScintHit G__TTHaNAScintHit;
static int G__HANDDict_240_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[] (THaNAScintHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaNAScintHit*) (soff+(sizeof(THaNAScintHit)*i)))->~G__TTHaNAScintHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaNAScintHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaNAScintHit*) (soff))->~G__TTHaNAScintHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__HANDDict_240_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNAScintHit* dest = (THaNAScintHit*) G__getstructoffset();
   *dest = *(THaNAScintHit*) libp->para[0].ref;
   const THaNAScintHit& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaScintillatorPlane */
static int G__HANDDict_242_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaScintillatorPlane* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaScintillatorPlane(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (THaApparatus*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) THaScintillatorPlane(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (THaApparatus*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaScintillatorPlane((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THaScintillatorPlane((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaScintillatorPlane((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THaScintillatorPlane((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaScintillatorPlane*) G__getstructoffset())->IsHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->HitCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCCorLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCCorRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCCorLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCCorRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCOffLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTDCOffRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCPedLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCPedRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCGainLeft((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetADCGainRight((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetTDCOff((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetADCPed((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetADCGain((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetYPos((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetXYZBar((int) 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__HANDDict_242_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetTOFPar((int) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->SetBlockingBarRange((int) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaScintillatorPlane*) G__getstructoffset())->GetBlockingBarMin((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaScintillatorPlane*) G__getstructoffset())->GetBlockingBarMax((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetTOF((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetYPos((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetYBar((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetXBar((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaScintillatorPlane*) G__getstructoffset())->GetZBar((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaScintillatorPlane*) G__getstructoffset())->IsHit((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THaScintillatorPlane*) G__getstructoffset())->GetNHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaScintillatorPlane*) G__getstructoffset())->GetHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaScintillatorPlane*) G__getstructoffset())->GetHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaScintillatorPlane::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaScintillatorPlane::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaScintillatorPlane::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaScintillatorPlane::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaScintillatorPlane*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaScintillatorPlane::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaScintillatorPlane::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaScintillatorPlane::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_242_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaScintillatorPlane::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaScintillatorPlane G__TTHaScintillatorPlane;
static int G__HANDDict_242_0_56(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[] (THaScintillatorPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaScintillatorPlane*) (soff+(sizeof(THaScintillatorPlane)*i)))->~G__TTHaScintillatorPlane();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaScintillatorPlane*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaScintillatorPlane*) (soff))->~G__TTHaScintillatorPlane();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaNDTrack */
static int G__HANDDict_245_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNDTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack(
(Double_t) G__double(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) THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) THaNDTrack(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) THaNDTrack((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDTrack((Double_t) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) THaNDTrack((Double_t) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNDTrack[n];
       } else {
         p = new((void*) gvp) THaNDTrack[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNDTrack;
       } else {
         p = new((void*) gvp) THaNDTrack;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNDTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THaNDTrack(*(THaNDTrack*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) THaNDTrack(*(THaNDTrack*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDTrack*) G__getstructoffset())->GetNHits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNDTrack*) G__getstructoffset())->GetHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDTrack*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDTrack*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDTrack*) G__getstructoffset())->GetTOF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDTrack*) G__getstructoffset())->GetDist());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDTrack*) G__getstructoffset())->GetEnergyDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDTrack*) G__getstructoffset())->GetFirstHitPaddle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDTrack*) G__getstructoffset())->GetFirstHitPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDTrack*) G__getstructoffset())->AddHit((THaNAScintHit*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaNDTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaNDTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaNDTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNDTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNDTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_245_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNDTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaNDTrack G__TTHaNDTrack;
static int G__HANDDict_245_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[] (THaNDTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaNDTrack*) (soff+(sizeof(THaNDTrack)*i)))->~G__TTHaNDTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaNDTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaNDTrack*) (soff))->~G__TTHaNDTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__HANDDict_245_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNDTrack* dest = (THaNDTrack*) G__getstructoffset();
   *dest = *(THaNDTrack*) libp->para[0].ref;
   const THaNDTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaNeutronDetector */
static int G__HANDDict_246_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNeutronDetector* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THaNeutronDetector((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THaNeutronDetector((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNeutronDetector*) G__getstructoffset())->GetPlane1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNeutronDetector*) G__getstructoffset())->GetPlane2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNeutronDetector*) G__getstructoffset())->GetPlane3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNeutronDetector*) G__getstructoffset())->GetPlane4());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((THaNeutronDetector*) G__getstructoffset())->ConstructTracks((TClonesArray*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((THaNeutronDetector*) G__getstructoffset())->ConstructTracks());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNeutronDetector*) G__getstructoffset())->AddTrack((THaNDTrack*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNeutronDetector*) G__getstructoffset())->GetNDTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNeutronDetector*) G__getstructoffset())->GetNDTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNeutronDetector*) G__getstructoffset())->GetNTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNeutronDetector*) G__getstructoffset())->GetMinimumAngle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaNeutronDetector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNeutronDetector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaNeutronDetector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaNeutronDetector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNeutronDetector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNeutronDetector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNeutronDetector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNeutronDetector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_246_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNeutronDetector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaNeutronDetector G__TTHaNeutronDetector;
static int G__HANDDict_246_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[] (THaNeutronDetector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaNeutronDetector*) (soff+(sizeof(THaNeutronDetector)*i)))->~G__TTHaNeutronDetector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaNeutronDetector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaNeutronDetector*) (soff))->~G__TTHaNeutronDetector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaVeto */
static int G__HANDDict_248_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaVeto* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaVeto(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (THaApparatus*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) THaVeto(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (THaApparatus*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaVeto((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THaVeto((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaVeto((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THaVeto((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaVeto));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaVeto*) G__getstructoffset())->GetNegRegionLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaVeto*) G__getstructoffset())->GetPosRegionLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaVeto*) G__getstructoffset())->GetMinAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaVeto*) G__getstructoffset())->GetLeftIsHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaVeto*) G__getstructoffset())->GetRightIsHit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaVeto*) G__getstructoffset())->GetHitRegion((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaVeto::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaVeto::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaVeto::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaVeto::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaVeto*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaVeto::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaVeto::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaVeto::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_248_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaVeto::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaVeto G__TTHaVeto;
static int G__HANDDict_248_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[] (THaVeto*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaVeto*) (soff+(sizeof(THaVeto)*i)))->~G__TTHaVeto();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaVeto*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaVeto*) (soff))->~G__TTHaVeto();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaNDNeutron */
static int G__HANDDict_250_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNDNeutron* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (THaNAScintHit*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (THaNAScintHit*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(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) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) THaNDNeutron(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) THaNDNeutron((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaNDNeutron((Double_t) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) THaNDNeutron((Double_t) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNDNeutron[n];
       } else {
         p = new((void*) gvp) THaNDNeutron[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new THaNDNeutron;
       } else {
         p = new((void*) gvp) THaNDNeutron;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNDNeutron*) G__getstructoffset())->GetHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetTOF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetEnergyDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetDistance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDNeutron*) G__getstructoffset())->GetHitPaddle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNDNeutron*) G__getstructoffset())->GetHitPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaNDNeutron*) G__getstructoffset())->GetCosine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNDNeutron*) G__getstructoffset())->SetCosine((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaNDNeutron::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDNeutron::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaNDNeutron::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaNDNeutron::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNDNeutron*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDNeutron::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNDNeutron::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNDNeutron::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_250_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNDNeutron::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__HANDDict_250_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THaNDNeutron* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THaNDNeutron(*(THaNDNeutron*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaNDNeutron G__TTHaNDNeutron;
static int G__HANDDict_250_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[] (THaNDNeutron*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaNDNeutron*) (soff+(sizeof(THaNDNeutron)*i)))->~G__TTHaNDNeutron();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaNDNeutron*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaNDNeutron*) (soff))->~G__TTHaNDNeutron();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__HANDDict_250_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNDNeutron* dest = (THaNDNeutron*) G__getstructoffset();
   *dest = *(THaNDNeutron*) libp->para[0].ref;
   const THaNDNeutron& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaNA */
static int G__HANDDict_251_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaNA* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THaNA((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THaNA((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaNA));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNA*) G__getstructoffset())->GetNeutronDetector());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaNA*) G__getstructoffset())->GetVeto());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->GetNTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNA*) G__getstructoffset())->GetNDTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->GetNNeutrons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((THaNA*) G__getstructoffset())->GetNDNeutron((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->InitBlockingBars(*(TDatime*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->CoarseProcess());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->TrackReconstruct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->GetTrackCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaNA*) G__getstructoffset())->GetTrackVetos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaNA*) G__getstructoffset())->GetThetaGeo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaNA*) G__getstructoffset())->GetPhiGeo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaNA*) G__getstructoffset())->GetThetaSph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaNA*) G__getstructoffset())->GetPhiSph());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaNA*) G__getstructoffset())->GetDistance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->AddwvTrack((THaNDTrack*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaNA*) G__getstructoffset())->AddwovTrack((THaNDTrack*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNA*) G__getstructoffset())->SetNeutronVetoTimeLimits((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaNA::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNA::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaNA::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaNA::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaNA*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNA::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNA::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaNA::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_251_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaNA::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaNA G__TTHaNA;
static int G__HANDDict_251_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[] (THaNA*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaNA*) (soff+(sizeof(THaNA)*i)))->~G__TTHaNA();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaNA*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaNA*) (soff))->~G__TTHaNA();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaPaddle */
static int G__HANDDict_253_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPaddle*) G__getstructoffset())->SetPaddleNumber((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((THaPaddle*) G__getstructoffset())->GetPaddleNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaPaddle*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaPaddle*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaPaddle*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((THaPaddle*) G__getstructoffset())->GetYPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPaddle*) G__getstructoffset())->SetX((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPaddle*) G__getstructoffset())->SetY((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPaddle*) G__getstructoffset())->SetZ((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((THaPaddle*) G__getstructoffset())->IsHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaPaddle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPaddle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaPaddle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaPaddle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPaddle*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPaddle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPaddle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPaddle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_253_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPaddle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaPaddle G__TTHaPaddle;
static int G__HANDDict_253_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[] (THaPaddle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaPaddle*) (soff+(sizeof(THaPaddle)*i)))->~G__TTHaPaddle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaPaddle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaPaddle*) (soff))->~G__TTHaPaddle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__HANDDict_253_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaPaddle* dest = (THaPaddle*) G__getstructoffset();
   *dest = *(THaPaddle*) libp->para[0].ref;
   const THaPaddle& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaPlaneHit */
static int G__HANDDict_254_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaPlaneHit* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaPlaneHit[n];
     } else {
       p = new((void*) gvp) THaPlaneHit[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaPlaneHit;
     } else {
       p = new((void*) gvp) THaPlaneHit;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaPlaneHit* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THaPlaneHit((THaPaddle*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) THaPlaneHit((THaPaddle*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaPlaneHit*) G__getstructoffset())->GetPaddle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const THaPlaneHit*) G__getstructoffset())->GetPaddleNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaPlaneHit*) G__getstructoffset())->GetXPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const THaPlaneHit*) G__getstructoffset())->GetYPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const THaPlaneHit*) G__getstructoffset())->GetPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPlaneHit*) G__getstructoffset())->SetPlane((THaPlane*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPlaneHit*) G__getstructoffset())->SetPaddle((THaPaddle*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaPlaneHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlaneHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaPlaneHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaPlaneHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaPlaneHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlaneHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPlaneHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaPlaneHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__HANDDict_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaPlaneHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaPlaneHit G__TTHaPlaneHit;
static int G__HANDDict_254_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[] (THaPlaneHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaPlaneHit*) (soff+(sizeof(THaPlaneHit)*i)))->~G__TTHaPlaneHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaPlaneHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaPlaneHit*) (soff))->~G__TTHaPlaneHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* THaPlane */

/* THaNAScintHit */

/* THaScintillatorPlane */

/* THaNDTrack */

/* THaNeutronDetector */

/* THaVeto */

/* THaNDNeutron */

/* THaNA */

/* THaPaddle */

/* THaPlaneHit */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncHANDDict {
 public:
  G__Sizep2memfuncHANDDict(): p(&G__Sizep2memfuncHANDDict::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncHANDDict::*p)();
};

size_t G__get_sizep2memfuncHANDDict()
{
  G__Sizep2memfuncHANDDict 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_inheritanceHANDDict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaPlane))) {
     THaPlane *G__Lderived;
     G__Lderived=(THaPlane*)0x1000;
     {
       THaNonTrackingDetector *G__Lpbase=(THaNonTrackingDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_THaNonTrackingDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THaSpectrometerDetector *G__Lpbase=(THaSpectrometerDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_THaSpectrometerDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetector *G__Lpbase=(THaDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_THaDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetectorBase *G__Lpbase=(THaDetectorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_THaDetectorBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaAnalysisObject *G__Lpbase=(THaAnalysisObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit))) {
     THaNAScintHit *G__Lderived;
     G__Lderived=(THaNAScintHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane))) {
     THaScintillatorPlane *G__Lderived;
     G__Lderived=(THaScintillatorPlane*)0x1000;
     {
       THaPlane *G__Lpbase=(THaPlane*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaPlane),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THaNonTrackingDetector *G__Lpbase=(THaNonTrackingDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaNonTrackingDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaSpectrometerDetector *G__Lpbase=(THaSpectrometerDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaSpectrometerDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetector *G__Lpbase=(THaDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetectorBase *G__Lpbase=(THaDetectorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaDetectorBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaAnalysisObject *G__Lpbase=(THaAnalysisObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack))) {
     THaNDTrack *G__Lderived;
     G__Lderived=(THaNDTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector))) {
     THaNeutronDetector *G__Lderived;
     G__Lderived=(THaNeutronDetector*)0x1000;
     {
       THaNonTrackingDetector *G__Lpbase=(THaNonTrackingDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_THaNonTrackingDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THaSpectrometerDetector *G__Lpbase=(THaSpectrometerDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_THaSpectrometerDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetector *G__Lpbase=(THaDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_THaDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetectorBase *G__Lpbase=(THaDetectorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_THaDetectorBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaAnalysisObject *G__Lpbase=(THaAnalysisObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaVeto))) {
     THaVeto *G__Lderived;
     G__Lderived=(THaVeto*)0x1000;
     {
       THaScintillatorPlane *G__Lpbase=(THaScintillatorPlane*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THaPlane *G__Lpbase=(THaPlane*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaPlane),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaNonTrackingDetector *G__Lpbase=(THaNonTrackingDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaNonTrackingDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaSpectrometerDetector *G__Lpbase=(THaSpectrometerDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaSpectrometerDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetector *G__Lpbase=(THaDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaDetectorBase *G__Lpbase=(THaDetectorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaDetectorBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       THaAnalysisObject *G__Lpbase=(THaAnalysisObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron))) {
     THaNDNeutron *G__Lderived;
     G__Lderived=(THaNDNeutron*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaNA))) {
     THaNA *G__Lderived;
     G__Lderived=(THaNA*)0x1000;
     {
       THaApparatus *G__Lpbase=(THaApparatus*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA),G__get_linked_tagnum(&G__HANDDictLN_THaApparatus),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       THaAnalysisObject *G__Lpbase=(THaAnalysisObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA),G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA),G__get_linked_tagnum(&G__HANDDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaPaddle))) {
     THaPaddle *G__Lderived;
     G__Lderived=(THaPaddle*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPaddle),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit))) {
     THaPlaneHit *G__Lderived;
     G__Lderived=(THaPlaneHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit),G__get_linked_tagnum(&G__HANDDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableHANDDict() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",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("vector<TSchemaHelper>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__HANDDictLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__HANDDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   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__HANDDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__HANDDictLN_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__HANDDictLN_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__HANDDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* THaPlane */
static void G__setup_memvarTHaPlane(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane));
   { THaPlane *p; p=(THaPlane*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaNAScintHit */
static void G__setup_memvarTHaNAScintHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit));
   { THaNAScintHit *p; p=(THaNAScintHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPaddleNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHitYPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHitTOF=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHitTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHitPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergyDeposit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaScintillatorPlane */
static void G__setup_memvarTHaScintillatorPlane(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane));
   { THaScintillatorPlane *p; p=(THaScintillatorPlane*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPaddlesHit=",0,(char*)NULL);
   G__memvar_setup((void*)0,82,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fFirstChan=",0,"Beginning channels for each detmap module");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClonesArray),-1,-1,2,"fHits=",0,"Hits in paddles (including multihits)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLTNhit=",0,"Number of Left paddles TDC times");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRTNhit=",0,"Number of Right paddles TDC times ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLANhit=",0,"Number of Left paddles ADC amplitudes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRANhit=",0,"Number of Right paddles ADC amplitudes");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLT=",0,"[fNelem] Left TDC time array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRT=",0,"[fNelem] Right TDC time array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLToff=",0,"[fNelem] Left TDC offset array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRToff=",0,"[fNelem] Right TDC offset array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLAped=",0,"[fNelem] Left ADC pedestal array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRAped=",0,"[fNelem] Right ADC pedestal array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLAgain=",0,"[fNelem] Left ADC gain array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRAgain=",0,"[fNelem] Right ADC gain array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLT_c=",0,"[fNelem] Left corrected TDC time array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRT_c=",0,"[fNelem] Right corrected TDC time array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLA=",0,"[fNelem] Left ADC amp array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRA=",0,"[fNelem] Right ADC amp array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLA_c=",0,"[fNelem] Left corrected ADC amp array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRA_c=",0,"[fNelem] Right corrected ADC amp array");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTDiff=",0,"[fNelem] Left minus Right TDC times   ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYPos=",0,"[fNelem] Y position along paddle");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYBar=",0,"[fNelem] Y position of the paddle");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXBar=",0,"[fNelem] X position of the paddle");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZBar=",0,"[fNelem] Z position of the paddle");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDist=",0,"[fNelem] Distance of the paddle from the target at Hall center (Neutron Detector at 6m).");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTOFOffset=",0,"[fNelem] Offset for TOF");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTOFScale=",0,"[fNelem] Scale factor for TOF");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYOffset=",0,"[fNelem] Offset for Y");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYScale=",0,"[fNelem] Scale factor for Y");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTOF=",0,"[fNelem] TOF to  paddle");
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsHit=",0,"[fNelem] Is Paddle hit ");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNLHits=",0,"[fNelem] Number of hits in left paddle");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNRHits=",0,"[fNelem] Number of hits in right paddle");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIBlockingBarMin=",0,"[fNelem] Smallest blocking bar id");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIBlockingBarMax=",0,"[fNelem] Smallest blocking bar id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_PaddleMultiHits),-1,-1,2,"fMultiHits=",0,"[fNelem] Array of multihits");
   G__memvar_setup((void*)0,99,0,1,-1,-1,-2,2,"NDEST=206329090",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlanecLcLDataDest),-1,-1,2,"fDataDest[2]=",0,"Lookup table for decoder");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaNDTrack */
static void G__setup_memvarTHaNDTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack));
   { THaNDTrack *p; p=(THaNDTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrackcLcLdA),-1,-2,1,"kMAXHIT=35",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTOF=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergyDeposit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDist=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFirstHitPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFirstHitPaddle=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNHits=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit),-1,-1,4,"fHits[35]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaNeutronDetector */
static void G__setup_memvarTHaNeutronDetector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector));
   { THaNeutronDetector *p; p=(THaNeutronDetector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane4=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetectorcLcLdA),-1,-2,1,"kMAXTRACKS=20",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNPlanesHit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),-1,-1,4,"fNDTracks[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTracks=",0,"Number of tracks found in ConstructTracks");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTheta[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNHits[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTOF[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDist[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergyDeposit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVetoHit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinAngle[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaVeto */
static void G__setup_memvarTHaVeto(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto));
   { THaVeto *p; p=(THaVeto*)0x1000; if (p) { }
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHitRegion=",0,"[fNelem]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPaddleOverlap=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinAngle=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNegRegionLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPosRegionLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLeftIsHit=",0,(char*)NULL);
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRightIsHit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaNDNeutron */
static void G__setup_memvarTHaNDNeutron(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron));
   { THaNDNeutron *p; p=(THaNDNeutron*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTheta=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTOF=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEnergyDeposit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDistance=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHitPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHitPaddle=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit),-1,-1,4,"fHit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCosine=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaNA */
static void G__setup_memvarTHaNA(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA));
   { THaNA *p; p=(THaNA*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__HANDDictLN_THaNAcLcLdA),-1,-2,1,"kMAXTRACKS=20",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,1,-1,G__defined_typename("Int_t"),-2,2,"kInitTrackMultiplicity=200",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClonesArray),-1,-1,2,"fTracks=",0,"Tracks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClonesArray),-1,-1,2,"fwvTracks=",0,"Tracks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClonesArray),-1,-1,2,"fwovTracks=",0,"Tracks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),-1,-1,2,"fNDTracks[20]=",0,"Tracks");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNHits[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTOF[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDist[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEnergyDeposit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFirstHitPaddle[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFirstHitPlane[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),-1,-1,2,"fNDwvTracks[20]=",0,"Tracks with veto hit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwvTheta[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwvPhi[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fwvNHits[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwvTOF[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwvEnergyDeposit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLeftIsHit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRightIsHit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),-1,-1,2,"fNDwovTracks[20]=",0,"Tracks without veto hit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwovTheta[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwovPhi[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fwovNHits[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwovTOF[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fwovEnergyDeposit[20]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetaGeo=",0,"In-plane geographic central angle (rad)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiGeo=",0,"Out-of-plane geographic central angle (rad) ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetaSph=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiSph=",0,"Central angles in spherical coords. (rad)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinThGeo=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosThGeo=",0,"Sine and cosine of central angles");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinPhGeo=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosPhGeo=",0,"in geographical coordinates");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinThSph=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosThSph=",0,"Sine and cosine of central angles in ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSinPhSph=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCosPhSph=",0,"spherical coordinates");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDistance=",0,"Distance from apparatus to target center (m)  ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCoarseDone=",0,"Coarse Reconstruct done");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),-1,-1,2,"fNeutronDetector=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaVeto),-1,-1,2,"fVeto=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNTracks=",0,"Number of tracks found in ConstructTracks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNwvTracks=",0,"Number of tracks found with veto hit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNwovTracks=",0,"Number of tracks found without veto hit");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__HANDDictLN_THaNAcLcLdA),-1,-2,1,"kMAXNEUTRONS=50",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNNeutrons=",0,"Number of neutrons found in NeutronProcess");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNTOF[50]=",0,"[fNNeutrons] Neutron Time");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPaddle[50]=",0,"[fNNeutrons] Neutron Bar #");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPlane[50]=",0,"[fNNeutrons] Neutron Array Plane");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNTheta[50]=",0,"[fNNeutrons] Neutron Theta ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNPhi[50]=",0,"[fNNeutrons] Neutron Phi ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNEnergyDeposit[50]=",0,"[fNNeutrons] Neutron Energy Deposit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNDist[50]=",0,"[fNNeutrons] Distance of hit bar to target");
   G__memvar_setup((void*)0,105,0,1,-1,G__defined_typename("Int_t"),-2,2,"kInitNeutronMultiplicity=200",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClonesArray),-1,-1,2,"fNeutrons=",0,"Neutrons passing veto criteria");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVetoPairs[300][10]=",0,"Track Plane");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane3=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),-1,-1,2,"fPlane4=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"VetoTimeMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"VetoTimeMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaPaddle */
static void G__setup_memvarTHaPaddle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPaddle));
   { THaPaddle *p; p=(THaPaddle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPaddleNumber=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaPlaneHit */
static void G__setup_memvarTHaPlaneHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit));
   { THaPlaneHit *p; p=(THaPlaneHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaPaddle),-1,-1,2,"fPaddle=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_THaPlane),-1,-1,2,"fPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__HANDDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarHANDDict() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTHaPlane(void) {
   /* THaPlane */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane));
   G__memfunc_setup("CoarseProcess",1340,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("FineProcess",1121,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsTracking",1007,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsPid",473,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__HANDDict_230_0_6, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaPlane::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_230_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlane::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_230_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaPlane::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_230_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaPlane::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_230_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_230_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlane::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_230_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPlane::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_230_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlane::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_230_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPlane::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaPlane", 875, G__HANDDict_230_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaNAScintHit(void) {
   /* THaNAScintHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit));
   G__memfunc_setup("THaNAScintHit",1202,G__HANDDict_240_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' paddle d - 'Double_t' 0 '0.0' ypos "
"d - 'Double_t' 0 '0.0' tof d - 'Double_t' 0 '0.0' energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaddleNumber",1491,G__HANDDict_240_0_2, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitYPos",976,G__HANDDict_240_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitTOF",814,G__HANDDict_240_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitTheta",1083,G__HANDDict_240_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitPhi",870,G__HANDDict_240_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergyDeposit",1634,G__HANDDict_240_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPaddleNumber",1503,G__HANDDict_240_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - paddle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYHitPos",988,G__HANDDict_240_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ypos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHitTOF",826,G__HANDDict_240_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnergyDeposit",1646,G__HANDDict_240_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - energy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHitAngles",1195,G__HANDDict_240_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__HANDDict_240_0_13, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaNAScintHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_240_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNAScintHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_240_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaNAScintHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_240_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaNAScintHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_240_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_240_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNAScintHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_240_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNAScintHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_240_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNAScintHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_240_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNAScintHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THaNAScintHit", 1202, G__HANDDict_240_0_25, (int) ('i'), G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 0, 1, 1, 1, 0, "u 'THaNAScintHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THaNAScintHit", 1328, G__HANDDict_240_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__HANDDict_240_0_27, (int) ('u'), G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 1, 1, 1, 1, 0, "u 'THaNAScintHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaScintillatorPlane(void) {
   /* THaScintillatorPlane */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane));
   G__memfunc_setup("THaScintillatorPlane",2021,G__HANDDict_242_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' description "
"U 'THaApparatus' - 0 'NULL' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Decode",580,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'THaEvData' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObjectcLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'TDatime' - 11 - run_time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CoarseProcess",1340,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FineProcess",1121,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsHit",481,G__HANDDict_242_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HitCount",814,G__HANDDict_242_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCCorLeft",1194,G__HANDDict_242_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCCorRight",1309,G__HANDDict_242_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCCorLeft",1175,G__HANDDict_242_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCCorRight",1290,G__HANDDict_242_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCLeft",883,G__HANDDict_242_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCRight",998,G__HANDDict_242_0_13, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCLeft",902,G__HANDDict_242_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCRight",1017,G__HANDDict_242_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCOffLeft",1185,G__HANDDict_242_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTDCOffRight",1300,G__HANDDict_242_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCPedLeft",1164,G__HANDDict_242_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCPedRight",1279,G__HANDDict_242_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCGainLeft",1266,G__HANDDict_242_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetADCGainRight",1381,G__HANDDict_242_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTDCOff",802,G__HANDDict_242_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - loff "
"d - 'Double_t' 0 - roff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetADCPed",781,G__HANDDict_242_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - lped "
"d - 'Double_t' 0 - rped", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetADCGain",883,G__HANDDict_242_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - lgain "
"d - 'Double_t' 0 - rgain", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYPos",695,G__HANDDict_242_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - offset "
"d - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYZBar",844,G__HANDDict_242_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTOFPar",824,G__HANDDict_242_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i d - 'Double_t' 0 - offset "
"d - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBlockingBarRange",1879,G__HANDDict_242_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i i - 'Int_t' 0 - bar_min "
"i - 'Int_t' 0 - bar_max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlockingBarMin",1666,G__HANDDict_242_0_29, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBlockingBarMax",1668,G__HANDDict_242_0_30, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTOF",521,G__HANDDict_242_0_31, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYPos",683,G__HANDDict_242_0_32, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYBar",654,G__HANDDict_242_0_33, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXBar",653,G__HANDDict_242_0_34, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZBar",655,G__HANDDict_242_0_35, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHit",481,G__HANDDict_242_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNHits",774,G__HANDDict_242_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHits",696,G__HANDDict_242_0_38, 85, G__get_linked_tagnum(&G__HANDDictLN_TClonesArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHit",581,G__HANDDict_242_0_39, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearEvent",1001,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteArrays",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDatabase",1169,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "u 'TDatime' - 11 - date", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineVariables",1508,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i 'THaAnalysisObject::EMode' - 0 'kDefine' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__HANDDict_242_0_44, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaScintillatorPlane::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_242_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaScintillatorPlane::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_242_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaScintillatorPlane::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_242_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaScintillatorPlane::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_242_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_242_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaScintillatorPlane::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_242_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaScintillatorPlane::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_242_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaScintillatorPlane::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_242_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaScintillatorPlane::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaScintillatorPlane", 2147, G__HANDDict_242_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaNDTrack(void) {
   /* THaNDTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack));
   G__memfunc_setup("THaNDTrack",900,G__HANDDict_245_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 '100.0' phi d - 'Double_t' 0 '100.0' theta "
"d - 'Double_t' 0 '0.0' tof d - 'Double_t' 0 '0.0' energy "
"d - 'Double_t' 0 '0.0' dist i - 'Int_t' 0 '-1' plane "
"i - 'Int_t' 0 '-1' pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THaNDTrack",900,G__HANDDict_245_0_2, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 0, 1, 1, 1, 0, "u 'THaNDTrack' - 11 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNHits",774,G__HANDDict_245_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHit",581,G__HANDDict_245_0_4, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi",577,G__HANDDict_245_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__HANDDict_245_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTOF",521,G__HANDDict_245_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDist",692,G__HANDDict_245_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergyDeposit",1634,G__HANDDict_245_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstHitPaddle",1687,G__HANDDict_245_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstHitPlane",1597,G__HANDDict_245_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddHit",558,G__HANDDict_245_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'THaNAScintHit' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__HANDDict_245_0_14, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaNDTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_245_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_245_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaNDTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_245_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaNDTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_245_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_245_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_245_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNDTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_245_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_245_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNDTrack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaNDTrack", 1026, G__HANDDict_245_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__HANDDict_245_0_27, (int) ('u'), G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 1, 1, 1, 1, 0, "u 'THaNDTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaNeutronDetector(void) {
   /* THaNeutronDetector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector));
   G__memfunc_setup("THaNeutronDetector",1826,G__HANDDict_246_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - description", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Decode",580,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'THaEvData' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObjectcLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'TDatime' - 11 - run_time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlane1",833,G__HANDDict_246_0_4, 85, G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlane2",834,G__HANDDict_246_0_5, 85, G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlane3",835,G__HANDDict_246_0_6, 85, G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlane4",836,G__HANDDict_246_0_7, 85, G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetApparatus",1245,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'THaApparatus' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CoarseProcess",1340,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FineProcess",1121,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TClonesArray' - 1 - tracks", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConstructTracks",1581,G__HANDDict_246_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TClonesArray' - 0 'NULL' tracks", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTrack",766,G__HANDDict_246_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'THaNDTrack' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDTracks",1050,G__HANDDict_246_0_13, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 2, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDTrack",935,G__HANDDict_246_0_14, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTracks",982,G__HANDDict_246_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimumAngle",1507,G__HANDDict_246_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector), -1, 1, 1, 1, 2, 0, "u 'THaNeutronDetector' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineVariables",1508,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i 'THaAnalysisObject::EMode' - 0 'kDefine' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 4, 0, 
"C - - 10 - name C - - 10 - desc "
"C - - 10 - p1nam C - - 10 - p2nam "
"C - - 10 - p3nam C - - 10 - p4nam "
"g - - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__HANDDict_246_0_21, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaNeutronDetector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_246_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNeutronDetector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_246_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaNeutronDetector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_246_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaNeutronDetector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_246_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_246_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNeutronDetector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_246_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNeutronDetector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_246_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNeutronDetector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_246_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNeutronDetector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaNeutronDetector", 1952, G__HANDDict_246_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaVeto(void) {
   /* THaVeto */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto));
   G__memfunc_setup("THaVeto",667,G__HANDDict_248_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaVeto), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' description "
"U 'THaApparatus' - 0 'NULL' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Decode",580,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'THaEvData' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNegRegionLimit",1693,G__HANDDict_248_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosRegionLimit",1717,G__HANDDict_248_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinAngle",1067,G__HANDDict_248_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftIsHit",1164,G__HANDDict_248_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightIsHit",1279,G__HANDDict_248_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitRegion",1193,G__HANDDict_248_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearEvent",1001,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteArrays",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDatabase",1169,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "u 'TDatime' - 11 - date", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineVariables",1508,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "i 'THaAnalysisObject::EMode' - 0 'kDefine' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__HANDDict_248_0_13, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaVeto::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_248_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaVeto::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_248_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaVeto::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_248_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaVeto::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_248_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_248_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaVeto::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_248_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaVeto::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_248_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaVeto::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_248_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaVeto::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaVeto", 793, G__HANDDict_248_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaNDNeutron(void) {
   /* THaNDNeutron */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron));
   G__memfunc_setup("THaNDNeutron",1146,G__HANDDict_250_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron), -1, 0, 8, 1, 1, 0, 
"d - 'Double_t' 0 '100.0' phi d - 'Double_t' 0 '100.0' theta "
"d - 'Double_t' 0 '-1.0' tof d - 'Double_t' 0 '-1.0' energy "
"d - 'Double_t' 0 '-1.0' distance i - 'Int_t' 0 '-1' plane "
"i - 'Int_t' 0 '-1' pad U 'THaNAScintHit' - 0 '0' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHit",581,G__HANDDict_250_0_2, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi",577,G__HANDDict_250_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__HANDDict_250_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTOF",521,G__HANDDict_250_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEnergyDeposit",1634,G__HANDDict_250_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistance",1099,G__HANDDict_250_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitPaddle",1167,G__HANDDict_250_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHitPlane",1077,G__HANDDict_250_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCosine",897,G__HANDDict_250_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCosine",909,G__HANDDict_250_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cosine", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__HANDDict_250_0_13, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaNDNeutron::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_250_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDNeutron::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_250_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaNDNeutron::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_250_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaNDNeutron::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_250_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_250_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDNeutron::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_250_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNDNeutron::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_250_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNDNeutron::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_250_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNDNeutron::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THaNDNeutron", 1146, G__HANDDict_250_0_25, (int) ('i'), G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron), -1, 0, 1, 1, 1, 0, "u 'THaNDNeutron' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THaNDNeutron", 1272, G__HANDDict_250_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__HANDDict_250_0_27, (int) ('u'), G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron), -1, 1, 1, 1, 1, 0, "u 'THaNDNeutron' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaNA(void) {
   /* THaNA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA));
   G__memfunc_setup("THaNA",396,G__HANDDict_251_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaNA), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - description", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeutronDetector",1861,G__HANDDict_251_0_2, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVeto",702,G__HANDDict_251_0_3, 85, G__get_linked_tagnum(&G__HANDDictLN_THaVeto), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTracks",982,G__HANDDict_251_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDTrack",935,G__HANDDict_251_0_5, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNeutrons",1228,G__HANDDict_251_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDNeutron",1181,G__HANDDict_251_0_7, 85, G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObjectcLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'TDatime' - 11 - run_time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitBlockingBars",1605,G__HANDDict_251_0_9, 105, G__get_linked_tagnum(&G__HANDDictLN_THaAnalysisObjectcLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'TDatime' - 11 - run_time", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CoarseProcess",1340,G__HANDDict_251_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reconstruct",1180,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TrackReconstruct",1681,G__HANDDict_251_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTrackCharge",1375,G__HANDDict_251_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTrackVetos",1318,G__HANDDict_251_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decode",580,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'THaEvData' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetThetaGeo",1073,G__HANDDict_251_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiGeo",860,G__HANDDict_251_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThetaSph",1089,G__HANDDict_251_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiSph",876,G__HANDDict_251_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistance",1099,G__HANDDict_251_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddwvTrack",1003,G__HANDDict_251_0_22, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'THaNDTrack' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddwovTrack",1114,G__HANDDict_251_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'THaNDTrack' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNeutronVetoTimeLimits",2486,G__HANDDict_251_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRunDatabase",1478,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "u 'TDatime' - 11 - date", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineVariables",1508,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i 'THaAnalysisObject::EMode' - 0 'kDefine' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NeutronProcess",1482,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"C - - 10 - name C - - 10 - desc "
"C - - 10 - ndnam C - - 10 - vnam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__HANDDict_251_0_29, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaNA::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_251_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNA::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_251_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaNA::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_251_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaNA::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_251_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_251_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNA::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_251_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNA::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_251_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaNA::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_251_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaNA::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaNA", 522, G__HANDDict_251_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaPaddle(void) {
   /* THaPaddle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPaddle));
   G__memfunc_setup("SetPaddleNumber",1503,G__HANDDict_253_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaddleNumber",1491,G__HANDDict_253_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__HANDDict_253_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__HANDDict_253_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__HANDDict_253_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYPos",683,G__HANDDict_253_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetX",388,G__HANDDict_253_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetY",389,G__HANDDict_253_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__HANDDict_253_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHit",481,G__HANDDict_253_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__HANDDict_253_0_12, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaPaddle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_253_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPaddle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_253_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaPaddle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_253_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaPaddle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_253_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_253_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPaddle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_253_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPaddle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_253_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPaddle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_253_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPaddle::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaPaddle", 965, G__HANDDict_253_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__HANDDict_253_0_25, (int) ('u'), G__get_linked_tagnum(&G__HANDDictLN_THaPaddle), -1, 1, 1, 1, 1, 0, "u 'THaPaddle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaPlaneHit(void) {
   /* THaPlaneHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit));
   G__memfunc_setup("THaPlaneHit",1042,G__HANDDict_254_0_1, 105, G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THaPlaneHit",1042,G__HANDDict_254_0_2, 105, G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit), -1, 0, 1, 1, 1, 0, "U 'THaPaddle' - 0 - paddle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaddle",874,G__HANDDict_254_0_3, 85, G__get_linked_tagnum(&G__HANDDictLN_THaPaddle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaddleNum",1178,G__HANDDict_254_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXPos",682,G__HANDDict_254_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYPos",683,G__HANDDict_254_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlane",784,G__HANDDict_254_0_7, 85, G__get_linked_tagnum(&G__HANDDictLN_THaPlane), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlane",796,G__HANDDict_254_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THaPlane' - 0 - plane", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPaddle",886,G__HANDDict_254_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'THaPaddle' - 0 - paddle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THaPlaneHit",1042,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit), -1, 0, 1, 1, 2, 0, "u 'THaPlaneHit' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit), -1, 1, 1, 1, 2, 0, "u 'THaPlaneHit' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__HANDDict_254_0_12, 85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaPlaneHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__HANDDict_254_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlaneHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__HANDDict_254_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaPlaneHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__HANDDict_254_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaPlaneHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__HANDDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__HANDDict_254_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__HANDDict_254_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlaneHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__HANDDict_254_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPlaneHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__HANDDict_254_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaPlaneHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__HANDDict_254_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaPlaneHit::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~THaPlaneHit", 1168, G__HANDDict_254_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncHANDDict() {
}

/*********************************************************
* 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() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalHANDDict() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* 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() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcHANDDict() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__HANDDictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaEvData = { "THaEvData" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaAnalysisObject = { "THaAnalysisObject" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaAnalysisObjectcLcLEStatus = { "THaAnalysisObject::EStatus" , 101 , -1 };
G__linked_taginfo G__HANDDictLN_THaAnalysisObjectcLcLEMode = { "THaAnalysisObject::EMode" , 101 , -1 };
G__linked_taginfo G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaDetectorBase = { "THaDetectorBase" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaDetector = { "THaDetector" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaApparatus = { "THaApparatus" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaSpectrometerDetector = { "THaSpectrometerDetector" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNonTrackingDetector = { "THaNonTrackingDetector" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaPlane = { "THaPlane" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__HANDDictLN_THaNAScintHit = { "THaNAScintHit" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_PaddleMultiHits = { "PaddleMultiHits" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaScintillatorPlane = { "THaScintillatorPlane" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaScintillatorPlanecLcLDataDest = { "THaScintillatorPlane::DataDest" , 115 , -1 };
G__linked_taginfo G__HANDDictLN_THaNDTrack = { "THaNDTrack" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNeutronDetector = { "THaNeutronDetector" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNeutronDetectorcLcLdA = { "THaNeutronDetector::$" , 101 , -1 };
G__linked_taginfo G__HANDDictLN_THaVeto = { "THaVeto" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNDTrackcLcLdA = { "THaNDTrack::$" , 101 , -1 };
G__linked_taginfo G__HANDDictLN_THaNDNeutron = { "THaNDNeutron" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNA = { "THaNA" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaNAcLcLdA = { "THaNA::$" , 101 , -1 };
G__linked_taginfo G__HANDDictLN_THaPaddle = { "THaPaddle" , 99 , -1 };
G__linked_taginfo G__HANDDictLN_THaPlaneHit = { "THaPlaneHit" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableHANDDict() {
  G__HANDDictLN_TClass.tagnum = -1 ;
  G__HANDDictLN_TBuffer.tagnum = -1 ;
  G__HANDDictLN_TMemberInspector.tagnum = -1 ;
  G__HANDDictLN_TObject.tagnum = -1 ;
  G__HANDDictLN_TNamed.tagnum = -1 ;
  G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__HANDDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__HANDDictLN_TClonesArray.tagnum = -1 ;
  G__HANDDictLN_TDatime.tagnum = -1 ;
  G__HANDDictLN_THaEvData.tagnum = -1 ;
  G__HANDDictLN_THaAnalysisObject.tagnum = -1 ;
  G__HANDDictLN_THaAnalysisObjectcLcLEStatus.tagnum = -1 ;
  G__HANDDictLN_THaAnalysisObjectcLcLEMode.tagnum = -1 ;
  G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__HANDDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__HANDDictLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__HANDDictLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__HANDDictLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__HANDDictLN_THaDetectorBase.tagnum = -1 ;
  G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__HANDDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__HANDDictLN_THaDetector.tagnum = -1 ;
  G__HANDDictLN_THaApparatus.tagnum = -1 ;
  G__HANDDictLN_THaSpectrometerDetector.tagnum = -1 ;
  G__HANDDictLN_THaNonTrackingDetector.tagnum = -1 ;
  G__HANDDictLN_THaPlane.tagnum = -1 ;
  G__HANDDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__HANDDictLN_THaNAScintHit.tagnum = -1 ;
  G__HANDDictLN_PaddleMultiHits.tagnum = -1 ;
  G__HANDDictLN_THaScintillatorPlane.tagnum = -1 ;
  G__HANDDictLN_THaScintillatorPlanecLcLDataDest.tagnum = -1 ;
  G__HANDDictLN_THaNDTrack.tagnum = -1 ;
  G__HANDDictLN_THaNeutronDetector.tagnum = -1 ;
  G__HANDDictLN_THaNeutronDetectorcLcLdA.tagnum = -1 ;
  G__HANDDictLN_THaVeto.tagnum = -1 ;
  G__HANDDictLN_THaNDTrackcLcLdA.tagnum = -1 ;
  G__HANDDictLN_THaNDNeutron.tagnum = -1 ;
  G__HANDDictLN_THaNA.tagnum = -1 ;
  G__HANDDictLN_THaNAcLcLdA.tagnum = -1 ;
  G__HANDDictLN_THaPaddle.tagnum = -1 ;
  G__HANDDictLN_THaPlaneHit.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableHANDDict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TClass);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TObject);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TNamed);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TClonesArray);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TDatime);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaEvData);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaAnalysisObject);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaAnalysisObjectcLcLEStatus);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaAnalysisObjectcLcLEMode);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaDetectorBase);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaDetector);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaApparatus);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaSpectrometerDetector);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaNonTrackingDetector);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlane),sizeof(THaPlane),-1,324611,"ABC for a BigBite scintillator detector",G__setup_memvarTHaPlane,G__setup_memfuncTHaPlane);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNAScintHit),sizeof(THaNAScintHit),-1,292096,(char*)NULL,G__setup_memvarTHaNAScintHit,G__setup_memfuncTHaNAScintHit);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_PaddleMultiHits);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaScintillatorPlane),sizeof(THaScintillatorPlane),-1,324608,"Generic trigger scintillator plane class",G__setup_memvarTHaScintillatorPlane,G__setup_memfuncTHaScintillatorPlane);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaScintillatorPlanecLcLDataDest);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDTrack),sizeof(THaNDTrack),-1,292608,(char*)NULL,G__setup_memvarTHaNDTrack,G__setup_memfuncTHaNDTrack);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNeutronDetector),sizeof(THaNeutronDetector),-1,326656,(char*)NULL,G__setup_memvarTHaNeutronDetector,G__setup_memfuncTHaNeutronDetector);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaNeutronDetectorcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaVeto),sizeof(THaVeto),-1,324608,"Generic trigger scintillator plane class",G__setup_memvarTHaVeto,G__setup_memfuncTHaVeto);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaNDTrackcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNDNeutron),sizeof(THaNDNeutron),-1,292096,(char*)NULL,G__setup_memvarTHaNDNeutron,G__setup_memfuncTHaNDNeutron);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaNA),sizeof(THaNA),-1,324608,"A generic non spectrometer apparatus",G__setup_memvarTHaNA,G__setup_memfuncTHaNA);
   G__get_linked_tagnum_fwd(&G__HANDDictLN_THaNAcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPaddle),sizeof(THaPaddle),-1,292098,"Generic scintillator paddle class",G__setup_memvarTHaPaddle,G__setup_memfuncTHaPaddle);
   G__tagtable_setup(G__get_linked_tagnum(&G__HANDDictLN_THaPlaneHit),sizeof(THaPlaneHit),-1,327424,(char*)NULL,G__setup_memvarTHaPlaneHit,G__setup_memfuncTHaPlaneHit);
}
extern "C" void G__cpp_setupHANDDict(void) {
  G__check_setup_version(30051515,"G__cpp_setupHANDDict()");
  G__set_cpp_environmentHANDDict();
  G__cpp_setup_tagtableHANDDict();

  G__cpp_setup_inheritanceHANDDict();

  G__cpp_setup_typetableHANDDict();

  G__cpp_setup_memvarHANDDict();

  G__cpp_setup_memfuncHANDDict();
  G__cpp_setup_globalHANDDict();
  G__cpp_setup_funcHANDDict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncHANDDict();
  return;
}
class G__cpp_setup_initHANDDict {
  public:
    G__cpp_setup_initHANDDict() { G__add_setup_func("HANDDict",(G__incsetup)(&G__cpp_setupHANDDict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initHANDDict() { G__remove_setup_func("HANDDict"); }
};
G__cpp_setup_initHANDDict G__cpp_setup_initializerHANDDict;