//
// File generated by /vols/comet00/users/bek07/ICEDUST/CernVMFSProject/packages/EXTERNALS/ROOT/Linux-x86_64/root-install/bin/rootcint at Mon Sep 14 04:24:04 2015

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

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

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

#include "TCollectionProxyInfo.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"
#include "TFileMergeInfo.h"

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      namespace COMET {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::COMET::IHandle< ::COMET::IReconState > IHandlelECOMETcLcLIReconStategR;
      #else
      class IHandlelECOMETcLcLIReconStategR  :  public ::COMET::IVHandle {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~IHandlelECOMETcLcLIReconStategR() throw() {};
      };
      #endif
      } 
   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void COMETcLcLIReconState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_COMETcLcLIReconState(void *p = 0);
   static void *newArray_COMETcLcLIReconState(Long_t size, void *p);
   static void delete_COMETcLcLIReconState(void *p);
   static void deleteArray_COMETcLcLIReconState(void *p);
   static void destruct_COMETcLcLIReconState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IReconState*)
   {
      ::COMET::IReconState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::COMET::IReconState >(0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IReconState", ::COMET::IReconState::Class_Version(), "./../src/IReconState.hxx", 50,
                  typeid(::COMET::IReconState), DefineBehavior(ptr, ptr),
                  &::COMET::IReconState::Dictionary, isa_proxy, 4,
                  sizeof(::COMET::IReconState) );
      instance.SetNew(&new_COMETcLcLIReconState);
      instance.SetNewArray(&newArray_COMETcLcLIReconState);
      instance.SetDelete(&delete_COMETcLcLIReconState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIReconState);
      instance.SetDestructor(&destruct_COMETcLcLIReconState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IReconState*)
   {
      return GenerateInitInstanceLocal((::COMET::IReconState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IReconState*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMReconState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMReconState_Dictionary();
   static void *new_COMETcLcLIMReconState(void *p = 0);
   static void *newArray_COMETcLcLIMReconState(Long_t size, void *p);
   static void delete_COMETcLcLIMReconState(void *p);
   static void deleteArray_COMETcLcLIMReconState(void *p);
   static void destruct_COMETcLcLIMReconState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMReconState*)
   {
      ::COMET::IMReconState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMReconState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMReconState", "./../src/IReconState.hxx", 140,
                  typeid(::COMET::IMReconState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMReconState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMReconState) );
      instance.SetNew(&new_COMETcLcLIMReconState);
      instance.SetNewArray(&newArray_COMETcLcLIMReconState);
      instance.SetDelete(&delete_COMETcLcLIMReconState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMReconState);
      instance.SetDestructor(&destruct_COMETcLcLIMReconState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMReconState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMReconState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMReconState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMReconState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMReconState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMEDepositState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMEDepositState_Dictionary();
   static void *new_COMETcLcLIMEDepositState(void *p = 0);
   static void *newArray_COMETcLcLIMEDepositState(Long_t size, void *p);
   static void delete_COMETcLcLIMEDepositState(void *p);
   static void deleteArray_COMETcLcLIMEDepositState(void *p);
   static void destruct_COMETcLcLIMEDepositState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMEDepositState*)
   {
      ::COMET::IMEDepositState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMEDepositState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMEDepositState", "./../src/IReconState.hxx", 166,
                  typeid(::COMET::IMEDepositState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMEDepositState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMEDepositState) );
      instance.SetNew(&new_COMETcLcLIMEDepositState);
      instance.SetNewArray(&newArray_COMETcLcLIMEDepositState);
      instance.SetDelete(&delete_COMETcLcLIMEDepositState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMEDepositState);
      instance.SetDestructor(&destruct_COMETcLcLIMEDepositState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMEDepositState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMEDepositState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMEDepositState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMEDepositState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMEDepositState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMPositionState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMPositionState_Dictionary();
   static void *new_COMETcLcLIMPositionState(void *p = 0);
   static void *newArray_COMETcLcLIMPositionState(Long_t size, void *p);
   static void delete_COMETcLcLIMPositionState(void *p);
   static void deleteArray_COMETcLcLIMPositionState(void *p);
   static void destruct_COMETcLcLIMPositionState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMPositionState*)
   {
      ::COMET::IMPositionState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMPositionState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMPositionState", "./../src/IReconState.hxx", 204,
                  typeid(::COMET::IMPositionState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMPositionState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMPositionState) );
      instance.SetNew(&new_COMETcLcLIMPositionState);
      instance.SetNewArray(&newArray_COMETcLcLIMPositionState);
      instance.SetDelete(&delete_COMETcLcLIMPositionState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMPositionState);
      instance.SetDestructor(&destruct_COMETcLcLIMPositionState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMPositionState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMPositionState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMPositionState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMPositionState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMPositionState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMDirectionState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMDirectionState_Dictionary();
   static void *new_COMETcLcLIMDirectionState(void *p = 0);
   static void *newArray_COMETcLcLIMDirectionState(Long_t size, void *p);
   static void delete_COMETcLcLIMDirectionState(void *p);
   static void deleteArray_COMETcLcLIMDirectionState(void *p);
   static void destruct_COMETcLcLIMDirectionState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMDirectionState*)
   {
      ::COMET::IMDirectionState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMDirectionState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMDirectionState", "./../src/IReconState.hxx", 261,
                  typeid(::COMET::IMDirectionState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMDirectionState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMDirectionState) );
      instance.SetNew(&new_COMETcLcLIMDirectionState);
      instance.SetNewArray(&newArray_COMETcLcLIMDirectionState);
      instance.SetDelete(&delete_COMETcLcLIMDirectionState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMDirectionState);
      instance.SetDestructor(&destruct_COMETcLcLIMDirectionState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMDirectionState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMDirectionState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMDirectionState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMDirectionState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMDirectionState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMPositionDirectionState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMPositionDirectionState_Dictionary();
   static void *new_COMETcLcLIMPositionDirectionState(void *p = 0);
   static void *newArray_COMETcLcLIMPositionDirectionState(Long_t size, void *p);
   static void delete_COMETcLcLIMPositionDirectionState(void *p);
   static void deleteArray_COMETcLcLIMPositionDirectionState(void *p);
   static void destruct_COMETcLcLIMPositionDirectionState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMPositionDirectionState*)
   {
      ::COMET::IMPositionDirectionState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMPositionDirectionState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMPositionDirectionState", "./../src/IReconState.hxx", 309,
                  typeid(::COMET::IMPositionDirectionState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMPositionDirectionState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMPositionDirectionState) );
      instance.SetNew(&new_COMETcLcLIMPositionDirectionState);
      instance.SetNewArray(&newArray_COMETcLcLIMPositionDirectionState);
      instance.SetDelete(&delete_COMETcLcLIMPositionDirectionState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMPositionDirectionState);
      instance.SetDestructor(&destruct_COMETcLcLIMPositionDirectionState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMPositionDirectionState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMPositionDirectionState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMPositionDirectionState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMPositionDirectionState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMPositionDirectionState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMConeState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMConeState_Dictionary();
   static void *new_COMETcLcLIMConeState(void *p = 0);
   static void *newArray_COMETcLcLIMConeState(Long_t size, void *p);
   static void delete_COMETcLcLIMConeState(void *p);
   static void deleteArray_COMETcLcLIMConeState(void *p);
   static void destruct_COMETcLcLIMConeState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMConeState*)
   {
      ::COMET::IMConeState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMConeState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMConeState", "./../src/IReconState.hxx", 330,
                  typeid(::COMET::IMConeState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMConeState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMConeState) );
      instance.SetNew(&new_COMETcLcLIMConeState);
      instance.SetNewArray(&newArray_COMETcLcLIMConeState);
      instance.SetDelete(&delete_COMETcLcLIMConeState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMConeState);
      instance.SetDestructor(&destruct_COMETcLcLIMConeState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMConeState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMConeState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMConeState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMConeState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMConeState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMCurvatureState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMCurvatureState_Dictionary();
   static void *new_COMETcLcLIMCurvatureState(void *p = 0);
   static void *newArray_COMETcLcLIMCurvatureState(Long_t size, void *p);
   static void delete_COMETcLcLIMCurvatureState(void *p);
   static void deleteArray_COMETcLcLIMCurvatureState(void *p);
   static void destruct_COMETcLcLIMCurvatureState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMCurvatureState*)
   {
      ::COMET::IMCurvatureState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMCurvatureState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMCurvatureState", "./../src/IReconState.hxx", 367,
                  typeid(::COMET::IMCurvatureState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMCurvatureState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMCurvatureState) );
      instance.SetNew(&new_COMETcLcLIMCurvatureState);
      instance.SetNewArray(&newArray_COMETcLcLIMCurvatureState);
      instance.SetDelete(&delete_COMETcLcLIMCurvatureState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMCurvatureState);
      instance.SetDestructor(&destruct_COMETcLcLIMCurvatureState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMCurvatureState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMCurvatureState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMCurvatureState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMCurvatureState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMCurvatureState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMPosDirCurvState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMPosDirCurvState_Dictionary();
   static void *new_COMETcLcLIMPosDirCurvState(void *p = 0);
   static void *newArray_COMETcLcLIMPosDirCurvState(Long_t size, void *p);
   static void delete_COMETcLcLIMPosDirCurvState(void *p);
   static void deleteArray_COMETcLcLIMPosDirCurvState(void *p);
   static void destruct_COMETcLcLIMPosDirCurvState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMPosDirCurvState*)
   {
      ::COMET::IMPosDirCurvState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMPosDirCurvState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMPosDirCurvState", "./../src/IReconState.hxx", 406,
                  typeid(::COMET::IMPosDirCurvState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMPosDirCurvState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMPosDirCurvState) );
      instance.SetNew(&new_COMETcLcLIMPosDirCurvState);
      instance.SetNewArray(&newArray_COMETcLcLIMPosDirCurvState);
      instance.SetDelete(&delete_COMETcLcLIMPosDirCurvState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMPosDirCurvState);
      instance.SetDestructor(&destruct_COMETcLcLIMPosDirCurvState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMPosDirCurvState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMPosDirCurvState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMPosDirCurvState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMPosDirCurvState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMPosDirCurvState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMWidthState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMWidthState_Dictionary();
   static void *new_COMETcLcLIMWidthState(void *p = 0);
   static void *newArray_COMETcLcLIMWidthState(Long_t size, void *p);
   static void delete_COMETcLcLIMWidthState(void *p);
   static void deleteArray_COMETcLcLIMWidthState(void *p);
   static void destruct_COMETcLcLIMWidthState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMWidthState*)
   {
      ::COMET::IMWidthState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMWidthState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMWidthState", "./../src/IReconState.hxx", 430,
                  typeid(::COMET::IMWidthState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMWidthState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMWidthState) );
      instance.SetNew(&new_COMETcLcLIMWidthState);
      instance.SetNewArray(&newArray_COMETcLcLIMWidthState);
      instance.SetDelete(&delete_COMETcLcLIMWidthState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMWidthState);
      instance.SetDestructor(&destruct_COMETcLcLIMWidthState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMWidthState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMWidthState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMWidthState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMWidthState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMWidthState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMMomentumState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMMomentumState_Dictionary();
   static void *new_COMETcLcLIMMomentumState(void *p = 0);
   static void *newArray_COMETcLcLIMMomentumState(Long_t size, void *p);
   static void delete_COMETcLcLIMMomentumState(void *p);
   static void deleteArray_COMETcLcLIMMomentumState(void *p);
   static void destruct_COMETcLcLIMMomentumState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMMomentumState*)
   {
      ::COMET::IMMomentumState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMMomentumState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMMomentumState", "./../src/IReconState.hxx", 467,
                  typeid(::COMET::IMMomentumState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMMomentumState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMMomentumState) );
      instance.SetNew(&new_COMETcLcLIMMomentumState);
      instance.SetNewArray(&newArray_COMETcLcLIMMomentumState);
      instance.SetDelete(&delete_COMETcLcLIMMomentumState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMMomentumState);
      instance.SetDestructor(&destruct_COMETcLcLIMMomentumState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMMomentumState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMMomentumState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMMomentumState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMMomentumState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMMomentumState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIMChargeState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIMChargeState_Dictionary();
   static void *new_COMETcLcLIMChargeState(void *p = 0);
   static void *newArray_COMETcLcLIMChargeState(Long_t size, void *p);
   static void delete_COMETcLcLIMChargeState(void *p);
   static void deleteArray_COMETcLcLIMChargeState(void *p);
   static void destruct_COMETcLcLIMChargeState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IMChargeState*)
   {
      ::COMET::IMChargeState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::COMET::IMChargeState),0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IMChargeState", "./../src/IReconState.hxx", 504,
                  typeid(::COMET::IMChargeState), DefineBehavior(ptr, ptr),
                  0, &COMETcLcLIMChargeState_Dictionary, isa_proxy, 1,
                  sizeof(::COMET::IMChargeState) );
      instance.SetNew(&new_COMETcLcLIMChargeState);
      instance.SetNewArray(&newArray_COMETcLcLIMChargeState);
      instance.SetDelete(&delete_COMETcLcLIMChargeState);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIMChargeState);
      instance.SetDestructor(&destruct_COMETcLcLIMChargeState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IMChargeState*)
   {
      return GenerateInitInstanceLocal((::COMET::IMChargeState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IMChargeState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIMChargeState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IMChargeState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void COMETcLcLIHandlelECOMETcLcLIReconStategR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void COMETcLcLIHandlelECOMETcLcLIReconStategR_Dictionary();
   static void *new_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p = 0);
   static void *newArray_COMETcLcLIHandlelECOMETcLcLIReconStategR(Long_t size, void *p);
   static void delete_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p);
   static void deleteArray_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p);
   static void destruct_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::COMET::IHandle<COMET::IReconState>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::COMET::IHandle<COMET::IReconState>) == sizeof(::ROOT::Shadow::COMET::IHandlelECOMETcLcLIReconStategR));
      ::COMET::IHandle<COMET::IReconState> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::COMET::IHandle<COMET::IReconState> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("COMET::IHandle<COMET::IReconState>", ::COMET::IHandle<COMET::IReconState>::Class_Version(), "./../src/IHandle.hxx", 106,
                  typeid(::COMET::IHandle<COMET::IReconState>), DefineBehavior(ptr, ptr),
                  &COMETcLcLIHandlelECOMETcLcLIReconStategR_Dictionary, isa_proxy, 4,
                  sizeof(::COMET::IHandle<COMET::IReconState>) );
      instance.SetNew(&new_COMETcLcLIHandlelECOMETcLcLIReconStategR);
      instance.SetNewArray(&newArray_COMETcLcLIHandlelECOMETcLcLIReconStategR);
      instance.SetDelete(&delete_COMETcLcLIHandlelECOMETcLcLIReconStategR);
      instance.SetDeleteArray(&deleteArray_COMETcLcLIHandlelECOMETcLcLIReconStategR);
      instance.SetDestructor(&destruct_COMETcLcLIHandlelECOMETcLcLIReconStategR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::COMET::IHandle<COMET::IReconState>*)
   {
      return GenerateInitInstanceLocal((::COMET::IHandle<COMET::IReconState>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void COMETcLcLIHandlelECOMETcLcLIReconStategR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0)->GetClass();
   }

} // end of namespace ROOT

      namespace COMET {
//______________________________________________________________________________
TClass *IReconState::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace COMET
      namespace COMET {
//______________________________________________________________________________
template <> TClass *IHandle<COMET::IReconState>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *IHandle<COMET::IReconState>::Class_Name()
{
   return "COMET::IHandle<COMET::IReconState>";
}

//______________________________________________________________________________
template <> const char *IHandle<COMET::IReconState>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int IHandle<COMET::IReconState>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void IHandle<COMET::IReconState>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0)->GetClass();
}

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

} // namespace COMET
      namespace COMET {
//______________________________________________________________________________
void IReconState::Streamer(TBuffer &R__b)
{
   // Stream an object of class COMET::IReconState.

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

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

} // namespace COMET
namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIReconState(void *p) {
      return  p ? new(p) ::COMET::IReconState : new ::COMET::IReconState;
   }
   static void *newArray_COMETcLcLIReconState(Long_t nElements, void *p) {
      return p ? new(p) ::COMET::IReconState[nElements] : new ::COMET::IReconState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIReconState(void *p) {
      delete ((::COMET::IReconState*)p);
   }
   static void deleteArray_COMETcLcLIReconState(void *p) {
      delete [] ((::COMET::IReconState*)p);
   }
   static void destruct_COMETcLcLIReconState(void *p) {
      typedef ::COMET::IReconState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IReconState

      namespace COMET {
//______________________________________________________________________________
template <> void IHandle<COMET::IReconState>::Streamer(TBuffer &R__b)
{
   // Stream an object of class COMET::IHandle<COMET::IReconState>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(COMET::IHandle<COMET::IReconState>::Class(),this);
   } else {
      R__b.WriteClassBuffer(COMET::IHandle<COMET::IReconState>::Class(),this);
   }
}

} // namespace COMET
//______________________________________________________________________________
namespace ROOT {
   void COMETcLcLIHandlelECOMETcLcLIReconStategR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class COMET::IHandle<COMET::IReconState>.
      typedef ::ROOT::Shadow::COMET::IHandlelECOMETcLcLIReconStategR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::COMET::IHandle<COMET::IReconState>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->COMET::IVHandle::ShowMembers(R__insp);
   }

}

      namespace COMET {
template <> void IHandle<COMET::IReconState>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::COMETcLcLIHandlelECOMETcLcLIReconStategR_ShowMembers(this, R__insp);
}

} // namespace COMET
namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p) {
      return  p ? new(p) ::COMET::IHandle<COMET::IReconState> : new ::COMET::IHandle<COMET::IReconState>;
   }
   static void *newArray_COMETcLcLIHandlelECOMETcLcLIReconStategR(Long_t nElements, void *p) {
      return p ? new(p) ::COMET::IHandle<COMET::IReconState>[nElements] : new ::COMET::IHandle<COMET::IReconState>[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p) {
      delete ((::COMET::IHandle<COMET::IReconState>*)p);
   }
   static void deleteArray_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p) {
      delete [] ((::COMET::IHandle<COMET::IReconState>*)p);
   }
   static void destruct_COMETcLcLIHandlelECOMETcLcLIReconStategR(void *p) {
      typedef ::COMET::IHandle<COMET::IReconState> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IHandle<COMET::IReconState>

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMReconState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMReconState : new ::COMET::IMReconState;
   }
   static void *newArray_COMETcLcLIMReconState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMReconState[nElements] : new ::COMET::IMReconState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMReconState(void *p) {
      delete ((::COMET::IMReconState*)p);
   }
   static void deleteArray_COMETcLcLIMReconState(void *p) {
      delete [] ((::COMET::IMReconState*)p);
   }
   static void destruct_COMETcLcLIMReconState(void *p) {
      typedef ::COMET::IMReconState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMReconState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMEDepositState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMEDepositState : new ::COMET::IMEDepositState;
   }
   static void *newArray_COMETcLcLIMEDepositState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMEDepositState[nElements] : new ::COMET::IMEDepositState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMEDepositState(void *p) {
      delete ((::COMET::IMEDepositState*)p);
   }
   static void deleteArray_COMETcLcLIMEDepositState(void *p) {
      delete [] ((::COMET::IMEDepositState*)p);
   }
   static void destruct_COMETcLcLIMEDepositState(void *p) {
      typedef ::COMET::IMEDepositState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMEDepositState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMPositionState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPositionState : new ::COMET::IMPositionState;
   }
   static void *newArray_COMETcLcLIMPositionState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPositionState[nElements] : new ::COMET::IMPositionState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMPositionState(void *p) {
      delete ((::COMET::IMPositionState*)p);
   }
   static void deleteArray_COMETcLcLIMPositionState(void *p) {
      delete [] ((::COMET::IMPositionState*)p);
   }
   static void destruct_COMETcLcLIMPositionState(void *p) {
      typedef ::COMET::IMPositionState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMPositionState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMDirectionState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMDirectionState : new ::COMET::IMDirectionState;
   }
   static void *newArray_COMETcLcLIMDirectionState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMDirectionState[nElements] : new ::COMET::IMDirectionState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMDirectionState(void *p) {
      delete ((::COMET::IMDirectionState*)p);
   }
   static void deleteArray_COMETcLcLIMDirectionState(void *p) {
      delete [] ((::COMET::IMDirectionState*)p);
   }
   static void destruct_COMETcLcLIMDirectionState(void *p) {
      typedef ::COMET::IMDirectionState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMDirectionState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMPositionDirectionState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPositionDirectionState : new ::COMET::IMPositionDirectionState;
   }
   static void *newArray_COMETcLcLIMPositionDirectionState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPositionDirectionState[nElements] : new ::COMET::IMPositionDirectionState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMPositionDirectionState(void *p) {
      delete ((::COMET::IMPositionDirectionState*)p);
   }
   static void deleteArray_COMETcLcLIMPositionDirectionState(void *p) {
      delete [] ((::COMET::IMPositionDirectionState*)p);
   }
   static void destruct_COMETcLcLIMPositionDirectionState(void *p) {
      typedef ::COMET::IMPositionDirectionState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMPositionDirectionState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMConeState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMConeState : new ::COMET::IMConeState;
   }
   static void *newArray_COMETcLcLIMConeState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMConeState[nElements] : new ::COMET::IMConeState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMConeState(void *p) {
      delete ((::COMET::IMConeState*)p);
   }
   static void deleteArray_COMETcLcLIMConeState(void *p) {
      delete [] ((::COMET::IMConeState*)p);
   }
   static void destruct_COMETcLcLIMConeState(void *p) {
      typedef ::COMET::IMConeState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMConeState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMCurvatureState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMCurvatureState : new ::COMET::IMCurvatureState;
   }
   static void *newArray_COMETcLcLIMCurvatureState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMCurvatureState[nElements] : new ::COMET::IMCurvatureState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMCurvatureState(void *p) {
      delete ((::COMET::IMCurvatureState*)p);
   }
   static void deleteArray_COMETcLcLIMCurvatureState(void *p) {
      delete [] ((::COMET::IMCurvatureState*)p);
   }
   static void destruct_COMETcLcLIMCurvatureState(void *p) {
      typedef ::COMET::IMCurvatureState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMCurvatureState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMPosDirCurvState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPosDirCurvState : new ::COMET::IMPosDirCurvState;
   }
   static void *newArray_COMETcLcLIMPosDirCurvState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMPosDirCurvState[nElements] : new ::COMET::IMPosDirCurvState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMPosDirCurvState(void *p) {
      delete ((::COMET::IMPosDirCurvState*)p);
   }
   static void deleteArray_COMETcLcLIMPosDirCurvState(void *p) {
      delete [] ((::COMET::IMPosDirCurvState*)p);
   }
   static void destruct_COMETcLcLIMPosDirCurvState(void *p) {
      typedef ::COMET::IMPosDirCurvState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMPosDirCurvState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMWidthState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMWidthState : new ::COMET::IMWidthState;
   }
   static void *newArray_COMETcLcLIMWidthState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMWidthState[nElements] : new ::COMET::IMWidthState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMWidthState(void *p) {
      delete ((::COMET::IMWidthState*)p);
   }
   static void deleteArray_COMETcLcLIMWidthState(void *p) {
      delete [] ((::COMET::IMWidthState*)p);
   }
   static void destruct_COMETcLcLIMWidthState(void *p) {
      typedef ::COMET::IMWidthState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMWidthState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMMomentumState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMMomentumState : new ::COMET::IMMomentumState;
   }
   static void *newArray_COMETcLcLIMMomentumState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMMomentumState[nElements] : new ::COMET::IMMomentumState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMMomentumState(void *p) {
      delete ((::COMET::IMMomentumState*)p);
   }
   static void deleteArray_COMETcLcLIMMomentumState(void *p) {
      delete [] ((::COMET::IMMomentumState*)p);
   }
   static void destruct_COMETcLcLIMMomentumState(void *p) {
      typedef ::COMET::IMMomentumState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMMomentumState

namespace ROOT {
   // Wrappers around operator new
   static void *new_COMETcLcLIMChargeState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMChargeState : new ::COMET::IMChargeState;
   }
   static void *newArray_COMETcLcLIMChargeState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::COMET::IMChargeState[nElements] : new ::COMET::IMChargeState[nElements];
   }
   // Wrapper around operator delete
   static void delete_COMETcLcLIMChargeState(void *p) {
      delete ((::COMET::IMChargeState*)p);
   }
   static void deleteArray_COMETcLcLIMChargeState(void *p) {
      delete [] ((::COMET::IMChargeState*)p);
   }
   static void destruct_COMETcLcLIMChargeState(void *p) {
      typedef ::COMET::IMChargeState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::COMET::IMChargeState

namespace ROOT {
   void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEstringgR_Dictionary();
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "/vols/comet00/users/bek07/ICEDUST/CernVMFSProject/packages/EXTERNALS/ROOT/Linux-x86_64/root-install/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<string>), DefineBehavior(ptr, ptr),
                  0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEstringgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<string>

/********************************************************
* ../dict/IReconState_Dict.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_tagtableIReconState_Dict();

extern "C" void G__set_cpp_environmentIReconState_Dict() {
  G__cpp_reset_tagtableIReconState_Dict();
}
#include <new>
extern "C" int G__cpp_dllrevIReconState_Dict() { return(30051515); }

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

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

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

static int G__IReconState_Dict_532_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const COMET::IReconState*) G__getstructoffset())->GetStateFields();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IReconState*) G__getstructoffset())->GetDimensions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IReconState*) G__getstructoffset())->GetValue((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IReconState*) G__getstructoffset())->SetValue((int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IReconState*) G__getstructoffset())->GetCovarianceValue((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IReconState*) G__getstructoffset())->SetCovarianceValue((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IReconState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IReconState*) G__getstructoffset())->SetFree((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const COMET::IReconState*) G__getstructoffset())->IsFree((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const COMET::IReconState*) G__getstructoffset())->IsFree((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IReconState*) G__getstructoffset())->SetFixed((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const COMET::IReconState*) G__getstructoffset())->IsFixed((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const COMET::IReconState*) G__getstructoffset())->IsFixed((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_532_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IReconState*) G__getstructoffset())->Validate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef COMET::IReconState G__TCOMETcLcLIReconState;
static int G__IReconState_Dict_532_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IReconState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IReconState*) (soff+(sizeof(COMET::IReconState)*i)))->~G__TCOMETcLcLIReconState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IReconState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IReconState*) (soff))->~G__TCOMETcLcLIReconState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__IReconState_Dict_533_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const COMET::IReconState& obj = ((const COMET::IMReconState*) G__getstructoffset())->GetThis();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMReconState G__TCOMETcLcLIMReconState;
static int G__IReconState_Dict_533_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMReconState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMReconState*) (soff+(sizeof(COMET::IMReconState)*i)))->~G__TCOMETcLcLIMReconState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMReconState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMReconState*) (soff))->~G__TCOMETcLcLIMReconState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_534_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMEDepositState*) G__getstructoffset())->GetEDeposit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMEDepositState*) G__getstructoffset())->SetEDeposit((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMEDepositState*) G__getstructoffset())->GetEDepositVariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMEDepositState*) G__getstructoffset())->SetEDepositVariance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMEDepositState*) G__getstructoffset())->GetEDepositIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMEDepositState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_534_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMEDepositState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMEDepositState G__TCOMETcLcLIMEDepositState;
static int G__IReconState_Dict_534_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMEDepositState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMEDepositState*) (soff+(sizeof(COMET::IMEDepositState)*i)))->~G__TCOMETcLcLIMEDepositState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMEDepositState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMEDepositState*) (soff))->~G__TCOMETcLcLIMEDepositState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_535_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TLorentzVector* pobj;
         const TLorentzVector xobj = ((const COMET::IMPositionState*) G__getstructoffset())->GetPosition();
         pobj = new TLorentzVector(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMPositionState*) G__getstructoffset())->SetPosition((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMPositionState*) G__getstructoffset())->SetPosition(*(TLorentzVector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TLorentzVector* pobj;
         const TLorentzVector xobj = ((const COMET::IMPositionState*) G__getstructoffset())->GetPositionVariance();
         pobj = new TLorentzVector(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMPositionState*) G__getstructoffset())->SetPositionVariance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMPositionState*) G__getstructoffset())->SetPositionCovariance((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__IReconState_Dict_535_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionState*) G__getstructoffset())->GetPositionIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionState*) G__getstructoffset())->GetXIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionState*) G__getstructoffset())->GetYIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionState*) G__getstructoffset())->GetZIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionState*) G__getstructoffset())->GetTIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMPositionState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_535_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMPositionState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMPositionState G__TCOMETcLcLIMPositionState;
static int G__IReconState_Dict_535_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMPositionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMPositionState*) (soff+(sizeof(COMET::IMPositionState)*i)))->~G__TCOMETcLcLIMPositionState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMPositionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMPositionState*) (soff))->~G__TCOMETcLcLIMPositionState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_536_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMDirectionState*) G__getstructoffset())->GetDirection();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMDirectionState*) G__getstructoffset())->SetDirection((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMDirectionState*) G__getstructoffset())->SetDirection(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMDirectionState*) G__getstructoffset())->GetDirectionVariance();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMDirectionState*) G__getstructoffset())->SetDirectionVariance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMDirectionState*) G__getstructoffset())->SetDirectionCovariance((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__IReconState_Dict_536_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMDirectionState*) G__getstructoffset())->GetDirectionIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMDirectionState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_536_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMDirectionState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMDirectionState G__TCOMETcLcLIMDirectionState;
static int G__IReconState_Dict_536_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMDirectionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMDirectionState*) (soff+(sizeof(COMET::IMDirectionState)*i)))->~G__TCOMETcLcLIMDirectionState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMDirectionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMDirectionState*) (soff))->~G__TCOMETcLcLIMDirectionState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_537_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPositionDirectionState*) G__getstructoffset())->GetPositionDirectionIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_537_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMPositionDirectionState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_537_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMPositionDirectionState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMPositionDirectionState G__TCOMETcLcLIMPositionDirectionState;
static int G__IReconState_Dict_537_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMPositionDirectionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMPositionDirectionState*) (soff+(sizeof(COMET::IMPositionDirectionState)*i)))->~G__TCOMETcLcLIMPositionDirectionState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMPositionDirectionState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMPositionDirectionState*) (soff))->~G__TCOMETcLcLIMPositionDirectionState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_538_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMConeState*) G__getstructoffset())->GetCone();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMConeState*) G__getstructoffset())->SetCone((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMConeState*) G__getstructoffset())->GetConeVariance();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMConeState*) G__getstructoffset())->SetConeVariance((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMConeState*) G__getstructoffset())->GetConeIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMConeState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_538_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMConeState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMConeState G__TCOMETcLcLIMConeState;
static int G__IReconState_Dict_538_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMConeState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMConeState*) (soff+(sizeof(COMET::IMConeState)*i)))->~G__TCOMETcLcLIMConeState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMConeState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMConeState*) (soff))->~G__TCOMETcLcLIMConeState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_539_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMCurvatureState*) G__getstructoffset())->GetCurvature());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMCurvatureState*) G__getstructoffset())->SetCurvature((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMCurvatureState*) G__getstructoffset())->GetCurvatureVariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMCurvatureState*) G__getstructoffset())->SetCurvatureVariance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMCurvatureState*) G__getstructoffset())->GetCurvatureIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMCurvatureState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_539_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMCurvatureState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMCurvatureState G__TCOMETcLcLIMCurvatureState;
static int G__IReconState_Dict_539_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMCurvatureState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMCurvatureState*) (soff+(sizeof(COMET::IMCurvatureState)*i)))->~G__TCOMETcLcLIMCurvatureState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMCurvatureState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMCurvatureState*) (soff))->~G__TCOMETcLcLIMCurvatureState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_540_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMPosDirCurvState*) G__getstructoffset())->GetPosDirCurvIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_540_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMPosDirCurvState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_540_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMPosDirCurvState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMPosDirCurvState G__TCOMETcLcLIMPosDirCurvState;
static int G__IReconState_Dict_540_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMPosDirCurvState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMPosDirCurvState*) (soff+(sizeof(COMET::IMPosDirCurvState)*i)))->~G__TCOMETcLcLIMPosDirCurvState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMPosDirCurvState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMPosDirCurvState*) (soff))->~G__TCOMETcLcLIMPosDirCurvState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_541_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMWidthState*) G__getstructoffset())->GetWidth();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMWidthState*) G__getstructoffset())->SetWidth((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const COMET::IMWidthState*) G__getstructoffset())->GetWidthVariance();
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMWidthState*) G__getstructoffset())->SetWidthVariance((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMWidthState*) G__getstructoffset())->GetWidthIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMWidthState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_541_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMWidthState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMWidthState G__TCOMETcLcLIMWidthState;
static int G__IReconState_Dict_541_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMWidthState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMWidthState*) (soff+(sizeof(COMET::IMWidthState)*i)))->~G__TCOMETcLcLIMWidthState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMWidthState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMWidthState*) (soff))->~G__TCOMETcLcLIMWidthState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_542_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMMomentumState*) G__getstructoffset())->GetMomentum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMMomentumState*) G__getstructoffset())->SetMomentum((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMMomentumState*) G__getstructoffset())->GetMomentumVariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMMomentumState*) G__getstructoffset())->SetMomentumVariance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMMomentumState*) G__getstructoffset())->GetMomentumIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMMomentumState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_542_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMMomentumState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMMomentumState G__TCOMETcLcLIMMomentumState;
static int G__IReconState_Dict_542_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMMomentumState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMMomentumState*) (soff+(sizeof(COMET::IMMomentumState)*i)))->~G__TCOMETcLcLIMMomentumState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMMomentumState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMMomentumState*) (soff))->~G__TCOMETcLcLIMMomentumState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__IReconState_Dict_543_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMChargeState*) G__getstructoffset())->GetCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMChargeState*) G__getstructoffset())->SetCharge((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const COMET::IMChargeState*) G__getstructoffset())->GetChargeVariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((COMET::IMChargeState*) G__getstructoffset())->SetChargeVariance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const COMET::IMChargeState*) G__getstructoffset())->GetChargeIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IMChargeState::GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_543_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         COMET::ICorrValues* pobj;
         COMET::ICorrValues xobj = COMET::IMChargeState::ProjectState(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         pobj = new COMET::ICorrValues(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef COMET::IMChargeState G__TCOMETcLcLIMChargeState;
static int G__IReconState_Dict_543_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IMChargeState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IMChargeState*) (soff+(sizeof(COMET::IMChargeState)*i)))->~G__TCOMETcLcLIMChargeState();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IMChargeState*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IMChargeState*) (soff))->~G__TCOMETcLcLIMChargeState();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

static int G__IReconState_Dict_549_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const COMET::IHandle<COMET::IReconState>& obj = ((COMET::IHandle<COMET::IReconState>*) G__getstructoffset())->operator=(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const COMET::IHandle<COMET::IReconState>& obj = ((COMET::IHandle<COMET::IReconState>*) G__getstructoffset())->operator=(*(COMET::IHandle<COMET::IReconState>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const COMET::IReconState& obj = ((const COMET::IHandle<COMET::IReconState>*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const COMET::IHandle<COMET::IReconState>*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) COMET::IHandle<COMET::IReconState>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) COMET::IHandle<COMET::IReconState>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) COMET::IHandle<COMET::IReconState>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      COMET::IHandle<COMET::IReconState>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__IReconState_Dict_549_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) COMET::IHandle<COMET::IReconState>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IHandle<COMET::IReconState>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) COMET::IHandle<COMET::IReconState>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__IReconState_Dict_549_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) COMET::IHandle<COMET::IReconState>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef COMET::IHandle<COMET::IReconState> G__TCOMETcLcLIHandlelECOMETcLcLIReconStategR;
static int G__IReconState_Dict_549_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (COMET::IHandle<COMET::IReconState>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((COMET::IHandle<COMET::IReconState>*) (soff+(sizeof(COMET::IHandle<COMET::IReconState>)*i)))->~G__TCOMETcLcLIHandlelECOMETcLcLIReconStategR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (COMET::IHandle<COMET::IReconState>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((COMET::IHandle<COMET::IReconState>*) (soff))->~G__TCOMETcLcLIHandlelECOMETcLcLIReconStategR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

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

/* COMET::IReconState */

/* COMET::IMReconState */

/* COMET::IMEDepositState */

/* COMET::IMPositionState */

/* COMET::IMDirectionState */

/* COMET::IMPositionDirectionState */

/* COMET::IMConeState */

/* COMET::IMCurvatureState */

/* COMET::IMPosDirCurvState */

/* COMET::IMWidthState */

/* COMET::IMMomentumState */

/* COMET::IMChargeState */

/* COMET::IHandle<COMET::IReconState> */

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

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

size_t G__get_sizep2memfuncIReconState_Dict()
{
  G__Sizep2memfuncIReconState_Dict a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */
static long G__2vbo_COMETcLcLIMEDepositState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMEDepositState *G__Lderived=(COMET::IMEDepositState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPositionState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMPositionState *G__Lderived=(COMET::IMPositionState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMDirectionState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMDirectionState *G__Lderived=(COMET::IMDirectionState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMPositionState_0(long pobject) {
  COMET::IMPositionDirectionState *G__Lderived=(COMET::IMPositionDirectionState*)pobject;
  COMET::IMPositionState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMReconState_1(long pobject) {
  COMET::IMPositionDirectionState *G__Lderived=(COMET::IMPositionDirectionState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMDirectionState_2(long pobject) {
  COMET::IMPositionDirectionState *G__Lderived=(COMET::IMPositionDirectionState*)pobject;
  COMET::IMDirectionState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMReconState_3(long pobject) {
  COMET::IMPositionDirectionState *G__Lderived=(COMET::IMPositionDirectionState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMConeState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMConeState *G__Lderived=(COMET::IMConeState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMCurvatureState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMCurvatureState *G__Lderived=(COMET::IMCurvatureState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMPositionDirectionState_0(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMPositionDirectionState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMPositionState_1(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMPositionState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_2(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMDirectionState_3(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMDirectionState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_4(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMCurvatureState_5(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMCurvatureState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_6(long pobject) {
  COMET::IMPosDirCurvState *G__Lderived=(COMET::IMPosDirCurvState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMWidthState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMWidthState *G__Lderived=(COMET::IMWidthState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMMomentumState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMMomentumState *G__Lderived=(COMET::IMMomentumState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_COMETcLcLIMChargeState_COMETcLcLIMReconState_0(long pobject) {
  COMET::IMChargeState *G__Lderived=(COMET::IMChargeState*)pobject;
  COMET::IMReconState *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}


/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceIReconState_Dict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState))) {
     COMET::IReconState *G__Lderived;
     G__Lderived=(COMET::IReconState*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState),G__get_linked_tagnum(&G__IReconState_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMEDepositState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPositionState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMDirectionState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState),(long)G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMPositionState_0,1,3);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMReconState_1,1,6);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState),(long)G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMDirectionState_2,1,3);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPositionDirectionState_COMETcLcLIMReconState_3,1,6);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMConeState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMCurvatureState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMPositionDirectionState_0,1,3);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMPositionState_1,1,6);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_2,1,6);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMDirectionState_3,1,6);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_4,1,6);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMCurvatureState_5,1,3);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMPosDirCurvState_COMETcLcLIMReconState_6,1,6);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMWidthState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMMomentumState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState))) {
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState),(long)G__2vbo_COMETcLcLIMChargeState_COMETcLcLIMReconState_0,1,3);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR))) {
     COMET::IHandle<COMET::IReconState> *G__Lderived;
     G__Lderived=(COMET::IHandle<COMET::IReconState>*)0x1000;
     {
       COMET::IVHandle *G__Lpbase=(COMET::IVHandle*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIVHandle),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),G__get_linked_tagnum(&G__IReconState_DictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

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

   /* Setting up typedef entry */
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__IReconState_DictLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,ErrorPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,ErrorPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,COMET::ICOMETLog::ErrorPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,COMET::ICOMETLog::ErrorPriority,less<string> >",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,LogPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,LogPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,COMET::ICOMETLog::LogPriority>",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,COMET::ICOMETLog::LogPriority,less<string> >",117,G__get_linked_tagnum(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__IReconState_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("COMET::IHandle<IReconState>",117,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState));
   G__setnewtype(-1,NULL,0);
}

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

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

   /* COMET::IReconState */
static void G__setup_memvarCOMETcLcLIReconState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState));
   { COMET::IReconState *p; p=(COMET::IReconState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues),-1,-1,2,"fValues=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fFieldNames=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* COMET::IMReconState */
static void G__setup_memvarCOMETcLcLIMReconState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState));
   { COMET::IMReconState *p; p=(COMET::IMReconState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState),-1,-1,4,"fThis=",0,"! do not save");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fLocalNames=",0,"! do not save");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMEDepositState */
static void G__setup_memvarCOMETcLcLIMEDepositState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState));
   { COMET::IMEDepositState *p; p=(COMET::IMEDepositState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fEDepositIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMPositionState */
static void G__setup_memvarCOMETcLcLIMPositionState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState));
   { COMET::IMPositionState *p; p=(COMET::IMPositionState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fPositionIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMDirectionState */
static void G__setup_memvarCOMETcLcLIMDirectionState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState));
   { COMET::IMDirectionState *p; p=(COMET::IMDirectionState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fDirectionIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMPositionDirectionState */
static void G__setup_memvarCOMETcLcLIMPositionDirectionState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState));
   { COMET::IMPositionDirectionState *p; p=(COMET::IMPositionDirectionState*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* COMET::IMConeState */
static void G__setup_memvarCOMETcLcLIMConeState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState));
   { COMET::IMConeState *p; p=(COMET::IMConeState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fConeIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMCurvatureState */
static void G__setup_memvarCOMETcLcLIMCurvatureState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState));
   { COMET::IMCurvatureState *p; p=(COMET::IMCurvatureState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fCurvatureIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMPosDirCurvState */
static void G__setup_memvarCOMETcLcLIMPosDirCurvState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState));
   { COMET::IMPosDirCurvState *p; p=(COMET::IMPosDirCurvState*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* COMET::IMWidthState */
static void G__setup_memvarCOMETcLcLIMWidthState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState));
   { COMET::IMWidthState *p; p=(COMET::IMWidthState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fWidthIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMMomentumState */
static void G__setup_memvarCOMETcLcLIMMomentumState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState));
   { COMET::IMMomentumState *p; p=(COMET::IMMomentumState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMomentumIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IMChargeState */
static void G__setup_memvarCOMETcLcLIMChargeState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState));
   { COMET::IMChargeState *p; p=(COMET::IMChargeState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fChargeIndex=",0,"! Do not save.");
   }
   G__tag_memvar_reset();
}


   /* COMET::IHandle<COMET::IReconState> */
static void G__setup_memvarCOMETcLcLIHandlelECOMETcLcLIReconStategR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR));
   { COMET::IHandle<COMET::IReconState> *p; p=(COMET::IHandle<COMET::IReconState>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__IReconState_DictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncCOMETcLcLIReconState(void) {
   /* COMET::IReconState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState));
   G__memfunc_setup("IReconState",1089,G__IReconState_Dict_532_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IReconState",1089,G__IReconState_Dict_532_0_2, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 0, 1, 1, 1, 0, "u 'COMET::IReconState' - 11 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStateFields",1400,G__IReconState_Dict_532_0_3, 117, G__get_linked_tagnum(&G__IReconState_DictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDimensions",1337,G__IReconState_Dict_532_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__IReconState_Dict_532_0_5, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__IReconState_Dict_532_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - i d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCovarianceValue",1816,G__IReconState_Dict_532_0_7, 100, -1, -1, 0, 2, 1, 1, 8, 
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCovarianceValue",1828,G__IReconState_Dict_532_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i i - - 0 - j "
"d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_532_0_9, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IReconState::ProjectState) ), 0);
   G__memfunc_setup("SetFree",686,G__IReconState_Dict_532_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFree",574,G__IReconState_Dict_532_0_11, 103, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFree",574,G__IReconState_Dict_532_0_12, 103, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixed",796,G__IReconState_Dict_532_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFixed",684,G__IReconState_Dict_532_0_14, 103, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFixed",684,G__IReconState_Dict_532_0_15, 103, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Validate",810,G__IReconState_Dict_532_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__IReconState_Dict_532_0_19, 85, G__get_linked_tagnum(&G__IReconState_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&COMET::IReconState::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__IReconState_Dict_532_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IReconState::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__IReconState_Dict_532_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&COMET::IReconState::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__IReconState_Dict_532_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&COMET::IReconState::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__IReconState_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__IReconState_Dict_532_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__IReconState_Dict_532_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IReconState::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__IReconState_Dict_532_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IReconState::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__IReconState_Dict_532_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IReconState::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__IReconState_Dict_532_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IReconState::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~IReconState", 1215, G__IReconState_Dict_532_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_532_0_32, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 1, 1, 1, 1, 0, "u 'COMET::IReconState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMReconState(void) {
   /* COMET::IMReconState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState));
   G__memfunc_setup("IMReconState",1166,G__IReconState_Dict_533_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IMReconState",1166,G__IReconState_Dict_533_0_2, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState), -1, 0, 1, 1, 1, 0, "U 'COMET::IReconState' - 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThis",696,G__IReconState_Dict_533_0_3, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("IMReconState", 1166, G__IReconState_Dict_533_0_4, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMReconState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMReconState", 1292, G__IReconState_Dict_533_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_533_0_6, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMReconState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMReconState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMEDepositState(void) {
   /* COMET::IMEDepositState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState));
   G__memfunc_setup("IMEDepositState",1460,G__IReconState_Dict_534_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEDeposit",1085,G__IReconState_Dict_534_0_2, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEDeposit",1097,G__IReconState_Dict_534_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - enr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEDepositVariance",1894,G__IReconState_Dict_534_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEDepositVariance",1906,G__IReconState_Dict_534_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEDepositIndex",1589,G__IReconState_Dict_534_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_534_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMEDepositState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_534_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMEDepositState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMEDepositState", 1460, G__IReconState_Dict_534_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMEDepositState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMEDepositState", 1586, G__IReconState_Dict_534_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_534_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMEDepositState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMEDepositState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMPositionState(void) {
   /* COMET::IMPositionState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState));
   G__memfunc_setup("IMPositionState",1516,G__IReconState_Dict_535_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__IReconState_Dict_535_0_2, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TLorentzVector), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__IReconState_Dict_535_0_3, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z d - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__IReconState_Dict_535_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TLorentzVector' - 11 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionVariance",1950,G__IReconState_Dict_535_0_5, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TLorentzVector), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositionVariance",1962,G__IReconState_Dict_535_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z d - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPositionCovariance",2172,G__IReconState_Dict_535_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i i - - 0 - j "
"d - - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionCovariance",2160,G__IReconState_Dict_535_0_8, 100, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionIndex",1645,G__IReconState_Dict_535_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXIndex",880,G__IReconState_Dict_535_0_10, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYIndex",881,G__IReconState_Dict_535_0_11, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZIndex",882,G__IReconState_Dict_535_0_12, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTIndex",876,G__IReconState_Dict_535_0_13, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_535_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMPositionState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_535_0_15, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMPositionState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMPositionState", 1516, G__IReconState_Dict_535_0_16, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMPositionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMPositionState", 1642, G__IReconState_Dict_535_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_535_0_18, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMPositionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMDirectionState(void) {
   /* COMET::IMDirectionState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState));
   G__memfunc_setup("IMDirectionState",1592,G__IReconState_Dict_536_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__IReconState_Dict_536_0_2, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirection",1229,G__IReconState_Dict_536_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirection",1229,G__IReconState_Dict_536_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectionVariance",2026,G__IReconState_Dict_536_0_5, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectionVariance",2038,G__IReconState_Dict_536_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectionCovariance",2248,G__IReconState_Dict_536_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - i i - - 0 - j "
"d - - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectionCovariance",2236,G__IReconState_Dict_536_0_8, 100, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - i i - - 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectionIndex",1721,G__IReconState_Dict_536_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_536_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMDirectionState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_536_0_11, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMDirectionState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMDirectionState", 1592, G__IReconState_Dict_536_0_12, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMDirectionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMDirectionState", 1718, G__IReconState_Dict_536_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_536_0_14, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMDirectionState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMDirectionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMPositionDirectionState(void) {
   /* COMET::IMPositionDirectionState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState));
   G__memfunc_setup("IMPositionDirectionState",2445,G__IReconState_Dict_537_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositionDirectionIndex",2574,G__IReconState_Dict_537_0_2, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_537_0_3, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMPositionDirectionState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_537_0_4, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMPositionDirectionState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMPositionDirectionState", 2445, G__IReconState_Dict_537_0_5, (int) ('i'), 
G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMPositionDirectionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMPositionDirectionState", 2571, G__IReconState_Dict_537_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_537_0_7, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMPositionDirectionState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMConeState(void) {
   /* COMET::IMConeState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState));
   G__memfunc_setup("IMConeState",1052,G__IReconState_Dict_538_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCone",677,G__IReconState_Dict_538_0_2, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCone",689,G__IReconState_Dict_538_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - c1 d - - 0 - c2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConeVariance",1486,G__IReconState_Dict_538_0_4, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConeVariance",1498,G__IReconState_Dict_538_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - c1 d - - 0 - c2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConeIndex",1181,G__IReconState_Dict_538_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_538_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMConeState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_538_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMConeState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMConeState", 1052, G__IReconState_Dict_538_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMConeState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMConeState", 1178, G__IReconState_Dict_538_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_538_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMConeState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMConeState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMCurvatureState(void) {
   /* COMET::IMCurvatureState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState));
   G__memfunc_setup("IMCurvatureState",1624,G__IReconState_Dict_539_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurvature",1249,G__IReconState_Dict_539_0_2, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurvature",1261,G__IReconState_Dict_539_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - enr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurvatureVariance",2058,G__IReconState_Dict_539_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurvatureVariance",2070,G__IReconState_Dict_539_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurvatureIndex",1753,G__IReconState_Dict_539_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_539_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMCurvatureState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_539_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMCurvatureState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMCurvatureState", 1624, G__IReconState_Dict_539_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMCurvatureState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMCurvatureState", 1750, G__IReconState_Dict_539_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_539_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMCurvatureState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMCurvatureState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMPosDirCurvState(void) {
   /* COMET::IMPosDirCurvState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState));
   G__memfunc_setup("IMPosDirCurvState",1672,G__IReconState_Dict_540_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosDirCurvIndex",1801,G__IReconState_Dict_540_0_2, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_540_0_3, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMPosDirCurvState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_540_0_4, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMPosDirCurvState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMPosDirCurvState", 1672, G__IReconState_Dict_540_0_5, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMPosDirCurvState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMPosDirCurvState", 1798, G__IReconState_Dict_540_0_6, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_540_0_7, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMPosDirCurvState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMWidthState(void) {
   /* COMET::IMWidthState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState));
   G__memfunc_setup("IMWidthState",1175,G__IReconState_Dict_541_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWidth",800,G__IReconState_Dict_541_0_2, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWidth",812,G__IReconState_Dict_541_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - w1 d - - 0 - w2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWidthVariance",1609,G__IReconState_Dict_541_0_4, 117, G__get_linked_tagnum(&G__IReconState_DictLN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWidthVariance",1621,G__IReconState_Dict_541_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - w1 d - - 0 - w2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWidthIndex",1304,G__IReconState_Dict_541_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_541_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMWidthState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_541_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMWidthState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMWidthState", 1175, G__IReconState_Dict_541_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMWidthState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMWidthState", 1301, G__IReconState_Dict_541_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_541_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMWidthState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMWidthState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMMomentumState(void) {
   /* COMET::IMMomentumState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState));
   G__memfunc_setup("IMMomentumState",1513,G__IReconState_Dict_542_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__IReconState_Dict_542_0_2, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__IReconState_Dict_542_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - enr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentumVariance",1947,G__IReconState_Dict_542_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentumVariance",1959,G__IReconState_Dict_542_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentumIndex",1642,G__IReconState_Dict_542_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_542_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMMomentumState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_542_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMMomentumState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMMomentumState", 1513, G__IReconState_Dict_542_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMMomentumState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMMomentumState", 1639, G__IReconState_Dict_542_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_542_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMMomentumState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMMomentumState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIMChargeState(void) {
   /* COMET::IMChargeState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState));
   G__memfunc_setup("IMChargeState",1249,G__IReconState_Dict_543_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCharge",874,G__IReconState_Dict_543_0_2, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCharge",886,G__IReconState_Dict_543_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - enr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChargeVariance",1683,G__IReconState_Dict_543_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChargeVariance",1695,G__IReconState_Dict_543_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChargeIndex",1378,G__IReconState_Dict_543_0_6, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__IReconState_Dict_543_0_7, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IMChargeState::GetSize) ), 0);
   G__memfunc_setup("ProjectState",1240,G__IReconState_Dict_543_0_8, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLICorrValues), -1, 0, 1, 3, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - state", (char*)NULL, (void*) G__func2void( (COMET::ICorrValues (*)(const COMET::IHandle<COMET::IReconState>&))(&COMET::IMChargeState::ProjectState) ), 0);
   // automatic copy constructor
   G__memfunc_setup("IMChargeState", 1249, G__IReconState_Dict_543_0_9, (int) ('i'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState), -1, 0, 1, 1, 1, 0, "u 'COMET::IMChargeState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IMChargeState", 1375, G__IReconState_Dict_543_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__IReconState_Dict_543_0_11, (int) ('u'), G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIMChargeState), -1, 1, 1, 1, 1, 0, "u 'COMET::IMChargeState' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncCOMETcLcLIHandlelECOMETcLcLIReconStategR(void) {
   /* COMET::IHandle<COMET::IReconState> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR));
   G__memfunc_setup("IHandle<COMET::IReconState>",2364,G__IReconState_Dict_549_0_1, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IHandle<COMET::IReconState>",2364,G__IReconState_Dict_549_0_2, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 0, 1, 5, 1, 0, "U 'COMET::IReconState' - 0 - pointee", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IHandle<COMET::IReconState>",2364,G__IReconState_Dict_549_0_3, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 0, 2, 1, 1, 0, 
"U 'COMET::IReconState' - 0 - pointee g - - 0 - owner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IHandle<COMET::IReconState>",2364,G__IReconState_Dict_549_0_4, 105, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 0, 1, 1, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__IReconState_Dict_549_0_5, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 1, 1, 1, 1, 0, "u 'COMET::IHandle<COMET::IReconState>' - 1 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__IReconState_Dict_549_0_6, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR), -1, 1, 1, 1, 1, 1, "u 'COMET::IHandle<COMET::IReconState>' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__IReconState_Dict_549_0_7, 117, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__IReconState_Dict_549_0_8, 85, G__get_linked_tagnum(&G__IReconState_DictLN_COMETcLcLIReconState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__IReconState_Dict_549_0_9, 85, G__get_linked_tagnum(&G__IReconState_DictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&COMET::IHandle<COMET::IReconState>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__IReconState_Dict_549_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IHandle<COMET::IReconState>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__IReconState_Dict_549_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&COMET::IHandle<COMET::IReconState>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__IReconState_Dict_549_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&COMET::IHandle<COMET::IReconState>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__IReconState_DictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__IReconState_Dict_549_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__IReconState_Dict_549_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IHandle<COMET::IReconState>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__IReconState_Dict_549_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IHandle<COMET::IReconState>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__IReconState_Dict_549_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&COMET::IHandle<COMET::IReconState>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__IReconState_Dict_549_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&COMET::IHandle<COMET::IReconState>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~IHandle<COMET::IReconState>", 2490, G__IReconState_Dict_549_0_21, (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_memfuncIReconState_Dict() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {

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

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcIReconState_Dict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__IReconState_DictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TVector3 = { "TVector3" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TLorentzVector = { "TLorentzVector" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMET = { "COMET" , 110 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLICorrValues = { "COMET::ICorrValues" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR = { "map<string,COMET::ICOMETLog::ErrorPriority,less<string>,allocator<pair<const string,COMET::ICOMETLog::ErrorPriority> > >" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR = { "map<string,COMET::ICOMETLog::LogPriority,less<string>,allocator<pair<const string,COMET::ICOMETLog::LogPriority> > >" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIVHandle = { "COMET::IVHandle" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIReconState = { "COMET::IReconState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMReconState = { "COMET::IMReconState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMEDepositState = { "COMET::IMEDepositState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMPositionState = { "COMET::IMPositionState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMDirectionState = { "COMET::IMDirectionState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMPositionDirectionState = { "COMET::IMPositionDirectionState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMConeState = { "COMET::IMConeState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMCurvatureState = { "COMET::IMCurvatureState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMPosDirCurvState = { "COMET::IMPosDirCurvState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMWidthState = { "COMET::IMWidthState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMMomentumState = { "COMET::IMMomentumState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIMChargeState = { "COMET::IMChargeState" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR = { "COMET::IHandle<COMET::IReconState>" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__IReconState_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableIReconState_Dict() {
  G__IReconState_DictLN_TClass.tagnum = -1 ;
  G__IReconState_DictLN_TBuffer.tagnum = -1 ;
  G__IReconState_DictLN_TMemberInspector.tagnum = -1 ;
  G__IReconState_DictLN_TObject.tagnum = -1 ;
  G__IReconState_DictLN_string.tagnum = -1 ;
  G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__IReconState_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__IReconState_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__IReconState_DictLN_TVector3.tagnum = -1 ;
  G__IReconState_DictLN_TLorentzVector.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__IReconState_DictLN_COMET.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLICorrValues.tagnum = -1 ;
  G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR.tagnum = -1 ;
  G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIVHandle.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIReconState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMReconState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMEDepositState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMPositionState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMDirectionState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMPositionDirectionState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMConeState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMCurvatureState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMPosDirCurvState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMWidthState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMMomentumState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIMChargeState.tagnum = -1 ;
  G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR.tagnum = -1 ;
  G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__IReconState_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableIReconState_Dict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TClass);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TObject);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_string);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TVector3);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TLorentzVector);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMET);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLICorrValues);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLErrorPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLErrorPrioritygRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_maplEstringcOCOMETcLcLICOMETLogcLcLLogPrioritycOlesslEstringgRcOallocatorlEpairlEconstsPstringcOCOMETcLcLICOMETLogcLcLLogPrioritygRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIVHandle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIReconState),sizeof(COMET::IReconState),-1,292608,(char*)NULL,G__setup_memvarCOMETcLcLIReconState,G__setup_memfuncCOMETcLcLIReconState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMReconState),sizeof(COMET::IMReconState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMReconState,G__setup_memfuncCOMETcLcLIMReconState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMEDepositState),sizeof(COMET::IMEDepositState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMEDepositState,G__setup_memfuncCOMETcLcLIMEDepositState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMPositionState),sizeof(COMET::IMPositionState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMPositionState,G__setup_memfuncCOMETcLcLIMPositionState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMDirectionState),sizeof(COMET::IMDirectionState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMDirectionState,G__setup_memfuncCOMETcLcLIMDirectionState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMPositionDirectionState),sizeof(COMET::IMPositionDirectionState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMPositionDirectionState,G__setup_memfuncCOMETcLcLIMPositionDirectionState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMConeState),sizeof(COMET::IMConeState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMConeState,G__setup_memfuncCOMETcLcLIMConeState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMCurvatureState),sizeof(COMET::IMCurvatureState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMCurvatureState,G__setup_memfuncCOMETcLcLIMCurvatureState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMPosDirCurvState),sizeof(COMET::IMPosDirCurvState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMPosDirCurvState,G__setup_memfuncCOMETcLcLIMPosDirCurvState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMWidthState),sizeof(COMET::IMWidthState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMWidthState,G__setup_memfuncCOMETcLcLIMWidthState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMMomentumState),sizeof(COMET::IMMomentumState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMMomentumState,G__setup_memfuncCOMETcLcLIMMomentumState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIMChargeState),sizeof(COMET::IMChargeState),-1,99584,(char*)NULL,G__setup_memvarCOMETcLcLIMChargeState,G__setup_memfuncCOMETcLcLIMChargeState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__IReconState_DictLN_COMETcLcLIHandlelECOMETcLcLIReconStategR),sizeof(COMET::IHandle<COMET::IReconState>),-1,327424,(char*)NULL,G__setup_memvarCOMETcLcLIHandlelECOMETcLcLIReconStategR,G__setup_memfuncCOMETcLcLIHandlelECOMETcLcLIReconStategR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__IReconState_DictLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupIReconState_Dict(void) {
  G__check_setup_version(30051515,"G__cpp_setupIReconState_Dict()");
  G__set_cpp_environmentIReconState_Dict();
  G__cpp_setup_tagtableIReconState_Dict();

  G__cpp_setup_inheritanceIReconState_Dict();

  G__cpp_setup_typetableIReconState_Dict();

  G__cpp_setup_memvarIReconState_Dict();

  G__cpp_setup_memfuncIReconState_Dict();
  G__cpp_setup_globalIReconState_Dict();
  G__cpp_setup_funcIReconState_Dict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncIReconState_Dict();
  return;
}
class G__cpp_setup_initIReconState_Dict {
  public:
    G__cpp_setup_initIReconState_Dict() { G__add_setup_func("IReconState_Dict",(G__incsetup)(&G__cpp_setupIReconState_Dict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initIReconState_Dict() { G__remove_setup_func("IReconState_Dict"); }
};
G__cpp_setup_initIReconState_Dict G__cpp_setup_initializerIReconState_Dict;