text: //
  // File generated by rootcint at Wed Apr  5 18:04:31 2017
  
  // Do NOT change. Changes will be lost next time file is generated
  //
  
  #define R__DICTIONARY_FILENAME dIhepstoredIrjonesdIExercisesdIRooUnfolddItmpdIlinuxx8664gccdIRooUnfoldDict
  #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 "RooUnfoldDict.h"
  
  #include "TClass.h"
  #include "TBuffer.h"
  #include "TMemberInspector.h"
  #include "TInterpreter.h"
  #include "TVirtualMutex.h"
  #include "TError.h"
  
  #ifndef G__ROOT
  #define G__ROOT
  #endif
  
  #include "RtypesImp.h"
  #include "TIsAProxy.h"
  #include "TFileMergeInfo.h"
  
  // Direct notice to TROOT of the dictionary's loading.
  namespace {
     static struct DictInit {
        DictInit() {
           ROOT::RegisterModule();
        }
     } __TheDictionaryInitializer;
  }
  
  // START OF SHADOWS
  
  namespace ROOTShadow {
     namespace Shadow {
     } // of namespace Shadow
  } // of namespace ROOTShadow
  // END OF SHADOWS
  
  namespace ROOTDict {
     void RooUnfoldResponse_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldResponse(void *p = 0);
     static void *newArray_RooUnfoldResponse(Long_t size, void *p);
     static void delete_RooUnfoldResponse(void *p);
     static void deleteArray_RooUnfoldResponse(void *p);
     static void destruct_RooUnfoldResponse(void *p);
     static void streamer_RooUnfoldResponse(TBuffer &buf, void *obj);
     static Long64_t merge_RooUnfoldResponse(void *obj, TCollection *coll,TFileMergeInfo *info);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldResponse*)
     {
        ::RooUnfoldResponse *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldResponse >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldResponse", ::RooUnfoldResponse::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldResponse.h", 29,
                    typeid(::RooUnfoldResponse), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldResponse::Dictionary, isa_proxy, 1,
                    sizeof(::RooUnfoldResponse) );
        instance.SetNew(&new_RooUnfoldResponse);
        instance.SetNewArray(&newArray_RooUnfoldResponse);
        instance.SetDelete(&delete_RooUnfoldResponse);
        instance.SetDeleteArray(&deleteArray_RooUnfoldResponse);
        instance.SetDestructor(&destruct_RooUnfoldResponse);
        instance.SetStreamerFunc(&streamer_RooUnfoldResponse);
        instance.SetMerge(&merge_RooUnfoldResponse);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldResponse*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldResponse*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldResponse*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfold_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfold(void *p = 0);
     static void *newArray_RooUnfold(Long_t size, void *p);
     static void delete_RooUnfold(void *p);
     static void deleteArray_RooUnfold(void *p);
     static void destruct_RooUnfold(void *p);
     static void streamer_RooUnfold(TBuffer &buf, void *obj);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfold*)
     {
        ::RooUnfold *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfold >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfold", ::RooUnfold::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfold.h", 23,
                    typeid(::RooUnfold), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfold::Dictionary, isa_proxy, 1,
                    sizeof(::RooUnfold) );
        instance.SetNew(&new_RooUnfold);
        instance.SetNewArray(&newArray_RooUnfold);
        instance.SetDelete(&delete_RooUnfold);
        instance.SetDeleteArray(&deleteArray_RooUnfold);
        instance.SetDestructor(&destruct_RooUnfold);
        instance.SetStreamerFunc(&streamer_RooUnfold);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfold*)
     {
        return GenerateInitInstanceLocal((::RooUnfold*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfold*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldBasisSplines_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldBasisSplines(void *p = 0);
     static void *newArray_RooUnfoldBasisSplines(Long_t size, void *p);
     static void delete_RooUnfoldBasisSplines(void *p);
     static void deleteArray_RooUnfoldBasisSplines(void *p);
     static void destruct_RooUnfoldBasisSplines(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldBasisSplines*)
     {
        ::RooUnfoldBasisSplines *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldBasisSplines >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldBasisSplines", ::RooUnfoldBasisSplines::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldBasisSplines.h", 29,
                    typeid(::RooUnfoldBasisSplines), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldBasisSplines::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldBasisSplines) );
        instance.SetNew(&new_RooUnfoldBasisSplines);
        instance.SetNewArray(&newArray_RooUnfoldBasisSplines);
        instance.SetDelete(&delete_RooUnfoldBasisSplines);
        instance.SetDeleteArray(&deleteArray_RooUnfoldBasisSplines);
        instance.SetDestructor(&destruct_RooUnfoldBasisSplines);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldBasisSplines*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldBasisSplines*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldBasisSplines*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldBayes_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldBayes(void *p = 0);
     static void *newArray_RooUnfoldBayes(Long_t size, void *p);
     static void delete_RooUnfoldBayes(void *p);
     static void deleteArray_RooUnfoldBayes(void *p);
     static void destruct_RooUnfoldBayes(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldBayes*)
     {
        ::RooUnfoldBayes *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldBayes >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldBayes", ::RooUnfoldBayes::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldBayes.h", 24,
                    typeid(::RooUnfoldBayes), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldBayes::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldBayes) );
        instance.SetNew(&new_RooUnfoldBayes);
        instance.SetNewArray(&newArray_RooUnfoldBayes);
        instance.SetDelete(&delete_RooUnfoldBayes);
        instance.SetDeleteArray(&deleteArray_RooUnfoldBayes);
        instance.SetDestructor(&destruct_RooUnfoldBayes);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldBayes*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldBayes*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldBayes*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldBinByBin_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldBinByBin(void *p = 0);
     static void *newArray_RooUnfoldBinByBin(Long_t size, void *p);
     static void delete_RooUnfoldBinByBin(void *p);
     static void deleteArray_RooUnfoldBinByBin(void *p);
     static void destruct_RooUnfoldBinByBin(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldBinByBin*)
     {
        ::RooUnfoldBinByBin *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldBinByBin >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldBinByBin", ::RooUnfoldBinByBin::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldBinByBin.h", 23,
                    typeid(::RooUnfoldBinByBin), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldBinByBin::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldBinByBin) );
        instance.SetNew(&new_RooUnfoldBinByBin);
        instance.SetNewArray(&newArray_RooUnfoldBinByBin);
        instance.SetDelete(&delete_RooUnfoldBinByBin);
        instance.SetDeleteArray(&deleteArray_RooUnfoldBinByBin);
        instance.SetDestructor(&destruct_RooUnfoldBinByBin);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldBinByBin*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldBinByBin*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldBinByBin*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldErrors_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void delete_RooUnfoldErrors(void *p);
     static void deleteArray_RooUnfoldErrors(void *p);
     static void destruct_RooUnfoldErrors(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldErrors*)
     {
        ::RooUnfoldErrors *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldErrors >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldErrors", ::RooUnfoldErrors::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldErrors.h", 21,
                    typeid(::RooUnfoldErrors), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldErrors::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldErrors) );
        instance.SetDelete(&delete_RooUnfoldErrors);
        instance.SetDeleteArray(&deleteArray_RooUnfoldErrors);
        instance.SetDestructor(&destruct_RooUnfoldErrors);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldErrors*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldErrors*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldErrors*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldInvert_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldInvert(void *p = 0);
     static void *newArray_RooUnfoldInvert(Long_t size, void *p);
     static void delete_RooUnfoldInvert(void *p);
     static void deleteArray_RooUnfoldInvert(void *p);
     static void destruct_RooUnfoldInvert(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldInvert*)
     {
        ::RooUnfoldInvert *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldInvert >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldInvert", ::RooUnfoldInvert::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldInvert.h", 25,
                    typeid(::RooUnfoldInvert), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldInvert::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldInvert) );
        instance.SetNew(&new_RooUnfoldInvert);
        instance.SetNewArray(&newArray_RooUnfoldInvert);
        instance.SetDelete(&delete_RooUnfoldInvert);
        instance.SetDeleteArray(&deleteArray_RooUnfoldInvert);
        instance.SetDestructor(&destruct_RooUnfoldInvert);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldInvert*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldInvert*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldInvert*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldParms_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldParms(void *p = 0);
     static void *newArray_RooUnfoldParms(Long_t size, void *p);
     static void delete_RooUnfoldParms(void *p);
     static void deleteArray_RooUnfoldParms(void *p);
     static void destruct_RooUnfoldParms(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldParms*)
     {
        ::RooUnfoldParms *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldParms >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldParms", ::RooUnfoldParms::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldParms.h", 22,
                    typeid(::RooUnfoldParms), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldParms::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldParms) );
        instance.SetNew(&new_RooUnfoldParms);
        instance.SetNewArray(&newArray_RooUnfoldParms);
        instance.SetDelete(&delete_RooUnfoldParms);
        instance.SetDeleteArray(&deleteArray_RooUnfoldParms);
        instance.SetDestructor(&destruct_RooUnfoldParms);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldParms*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldParms*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldParms*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void TSVDUnfold_130729_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void delete_TSVDUnfold_130729(void *p);
     static void deleteArray_TSVDUnfold_130729(void *p);
     static void destruct_TSVDUnfold_130729(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TSVDUnfold_130729*)
     {
        ::TSVDUnfold_130729 *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSVDUnfold_130729 >(0);
        static ::ROOT::TGenericClassInfo 
           instance("TSVDUnfold_130729", ::TSVDUnfold_130729::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/TSVDUnfold_local.h", 58,
                    typeid(::TSVDUnfold_130729), ::ROOT::DefineBehavior(ptr, ptr),
                    &::TSVDUnfold_130729::Dictionary, isa_proxy, 4,
                    sizeof(::TSVDUnfold_130729) );
        instance.SetDelete(&delete_TSVDUnfold_130729);
        instance.SetDeleteArray(&deleteArray_TSVDUnfold_130729);
        instance.SetDestructor(&destruct_TSVDUnfold_130729);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::TSVDUnfold_130729*)
     {
        return GenerateInitInstanceLocal((::TSVDUnfold_130729*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSVDUnfold_130729*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldSvd_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldSvd(void *p = 0);
     static void *newArray_RooUnfoldSvd(Long_t size, void *p);
     static void delete_RooUnfoldSvd(void *p);
     static void deleteArray_RooUnfoldSvd(void *p);
     static void destruct_RooUnfoldSvd(void *p);
     static void streamer_RooUnfoldSvd(TBuffer &buf, void *obj);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldSvd*)
     {
        ::RooUnfoldSvd *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldSvd >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldSvd", ::RooUnfoldSvd::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldSvd.h", 26,
                    typeid(::RooUnfoldSvd), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldSvd::Dictionary, isa_proxy, 1,
                    sizeof(::RooUnfoldSvd) );
        instance.SetNew(&new_RooUnfoldSvd);
        instance.SetNewArray(&newArray_RooUnfoldSvd);
        instance.SetDelete(&delete_RooUnfoldSvd);
        instance.SetDeleteArray(&deleteArray_RooUnfoldSvd);
        instance.SetDestructor(&destruct_RooUnfoldSvd);
        instance.SetStreamerFunc(&streamer_RooUnfoldSvd);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldSvd*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldSvd*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldSvd*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  namespace ROOTDict {
     void RooUnfoldTUnfold_ShowMembers(void *obj, TMemberInspector &R__insp);
     static void *new_RooUnfoldTUnfold(void *p = 0);
     static void *newArray_RooUnfoldTUnfold(Long_t size, void *p);
     static void delete_RooUnfoldTUnfold(void *p);
     static void deleteArray_RooUnfoldTUnfold(void *p);
     static void destruct_RooUnfoldTUnfold(void *p);
  
     // Function generating the singleton type initializer
     static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::RooUnfoldTUnfold*)
     {
        ::RooUnfoldTUnfold *ptr = 0;
        static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooUnfoldTUnfold >(0);
        static ::ROOT::TGenericClassInfo 
           instance("RooUnfoldTUnfold", ::RooUnfoldTUnfold::Class_Version(), "/hepstore/rjones/Exercises/RooUnfold/src/RooUnfoldTUnfold.h", 25,
                    typeid(::RooUnfoldTUnfold), ::ROOT::DefineBehavior(ptr, ptr),
                    &::RooUnfoldTUnfold::Dictionary, isa_proxy, 4,
                    sizeof(::RooUnfoldTUnfold) );
        instance.SetNew(&new_RooUnfoldTUnfold);
        instance.SetNewArray(&newArray_RooUnfoldTUnfold);
        instance.SetDelete(&delete_RooUnfoldTUnfold);
        instance.SetDeleteArray(&deleteArray_RooUnfoldTUnfold);
        instance.SetDestructor(&destruct_RooUnfoldTUnfold);
        return &instance;
     }
     ROOT::TGenericClassInfo *GenerateInitInstance(const ::RooUnfoldTUnfold*)
     {
        return GenerateInitInstanceLocal((::RooUnfoldTUnfold*)0);
     }
     // Static variable to force the class initialization
     static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooUnfoldTUnfold*)0x0); R__UseDummy(_R__UNIQUE_(Init));
  } // end of namespace ROOTDict
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldResponse::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldResponse::Class_Name()
  {
     return "RooUnfoldResponse";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldResponse::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldResponse*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldResponse::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldResponse*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldResponse::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldResponse*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldResponse::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldResponse*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfold::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfold::Class_Name()
  {
     return "RooUnfold";
  }
  
  //______________________________________________________________________________
  const char *RooUnfold::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfold*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfold::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfold*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfold::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfold*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfold::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfold*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldBasisSplines::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldBasisSplines::Class_Name()
  {
     return "RooUnfoldBasisSplines";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldBasisSplines::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBasisSplines*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldBasisSplines::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBasisSplines*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldBasisSplines::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBasisSplines*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldBasisSplines::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBasisSplines*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldBayes::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldBayes::Class_Name()
  {
     return "RooUnfoldBayes";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldBayes::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBayes*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldBayes::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBayes*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldBayes::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBayes*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldBayes::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBayes*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldBinByBin::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldBinByBin::Class_Name()
  {
     return "RooUnfoldBinByBin";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldBinByBin::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBinByBin*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldBinByBin::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBinByBin*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldBinByBin::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBinByBin*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldBinByBin::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldBinByBin*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldErrors::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldErrors::Class_Name()
  {
     return "RooUnfoldErrors";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldErrors::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldErrors*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldErrors::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldErrors*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldErrors::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldErrors*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldErrors::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldErrors*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldInvert::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldInvert::Class_Name()
  {
     return "RooUnfoldInvert";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldInvert::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldInvert*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldInvert::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldInvert*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldInvert::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldInvert*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldInvert::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldInvert*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldParms::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldParms::Class_Name()
  {
     return "RooUnfoldParms";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldParms::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldParms*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldParms::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldParms*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldParms::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldParms*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldParms::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldParms*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr TSVDUnfold_130729::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *TSVDUnfold_130729::Class_Name()
  {
     return "TSVDUnfold_130729";
  }
  
  //______________________________________________________________________________
  const char *TSVDUnfold_130729::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::TSVDUnfold_130729*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int TSVDUnfold_130729::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::TSVDUnfold_130729*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void TSVDUnfold_130729::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TSVDUnfold_130729*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *TSVDUnfold_130729::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TSVDUnfold_130729*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldSvd::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldSvd::Class_Name()
  {
     return "RooUnfoldSvd";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldSvd::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldSvd*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldSvd::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldSvd*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldSvd::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldSvd*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldSvd::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldSvd*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  atomic_TClass_ptr RooUnfoldTUnfold::fgIsA(0);  // static to hold class pointer
  
  //______________________________________________________________________________
  const char *RooUnfoldTUnfold::Class_Name()
  {
     return "RooUnfoldTUnfold";
  }
  
  //______________________________________________________________________________
  const char *RooUnfoldTUnfold::ImplFileName()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldTUnfold*)0x0)->GetImplFileName();
  }
  
  //______________________________________________________________________________
  int RooUnfoldTUnfold::ImplFileLine()
  {
     return ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldTUnfold*)0x0)->GetImplFileLine();
  }
  
  //______________________________________________________________________________
  void RooUnfoldTUnfold::Dictionary()
  {
     fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldTUnfold*)0x0)->GetClass();
  }
  
  //______________________________________________________________________________
  TClass *RooUnfoldTUnfold::Class()
  {
     if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::RooUnfoldTUnfold*)0x0)->GetClass();} }
     return fgIsA;
  }
  
  //______________________________________________________________________________
  void RooUnfold::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfold.
        TClass *R__cl = ::RooUnfold::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_minparm", &_minparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_maxparm", &_maxparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_stepsizeparm", &_stepsizeparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_defaultparm", &_defaultparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_verbose", &_verbose);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nm", &_nm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nt", &_nt);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_overflow", &_overflow);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_NToys", &_NToys);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_unfolded", &_unfolded);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_haveCov", &_haveCov);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_haveWgt", &_haveWgt);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_have_err_mat", &_have_err_mat);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_fail", &_fail);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_haveErrors", &_haveErrors);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_haveCovMes", &_haveCovMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_dosys", &_dosys);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_res", &_res);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_resmine", &_resmine);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_meas", &_meas);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_measmine", &_measmine);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_rec", &_rec);
        R__insp.InspectMember(_rec, "_rec.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_cov", &_cov);
        R__insp.InspectMember(_cov, "_cov.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_wgt", &_wgt);
        R__insp.InspectMember(_wgt, "_wgt.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_variances", &_variances);
        R__insp.InspectMember(_variances, "_variances.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_err_mat", &_err_mat);
        R__insp.InspectMember(_err_mat, "_err_mat.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_vMes", &_vMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_eMes", &_eMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_covMes", &_covMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_covL", &_covL);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_withError", &_withError);
        TNamed::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfold(void *p) {
        return  p ? new(p) ::RooUnfold : new ::RooUnfold;
     }
     static void *newArray_RooUnfold(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfold[nElements] : new ::RooUnfold[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfold(void *p) {
        delete ((::RooUnfold*)p);
     }
     static void deleteArray_RooUnfold(void *p) {
        delete [] ((::RooUnfold*)p);
     }
     static void destruct_RooUnfold(void *p) {
        typedef ::RooUnfold current_t;
        ((current_t*)p)->~current_t();
     }
     // Wrapper around a custom streamer member function.
     static void streamer_RooUnfold(TBuffer &buf, void *obj) {
        ((::RooUnfold*)obj)->::RooUnfold::Streamer(buf);
     }
  } // end of namespace ROOTDict for class ::RooUnfold
  
  //______________________________________________________________________________
  void RooUnfoldBayes::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldBayes.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldBayes::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldBayes::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldBayes::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldBayes.
        TClass *R__cl = ::RooUnfoldBayes::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_niter", &_niter);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_smoothit", &_smoothit);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nc", &_nc);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_ne", &_ne);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_N0C", &_N0C);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nbartrue", &_nbartrue);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nEstj", &_nEstj);
        R__insp.InspectMember(_nEstj, "_nEstj.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nCi", &_nCi);
        R__insp.InspectMember(_nCi, "_nCi.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nbarCi", &_nbarCi);
        R__insp.InspectMember(_nbarCi, "_nbarCi.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_efficiencyCi", &_efficiencyCi);
        R__insp.InspectMember(_efficiencyCi, "_efficiencyCi.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_P0C", &_P0C);
        R__insp.InspectMember(_P0C, "_P0C.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_UjInv", &_UjInv);
        R__insp.InspectMember(_UjInv, "_UjInv.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_Nji", &_Nji);
        R__insp.InspectMember(_Nji, "_Nji.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_Mij", &_Mij);
        R__insp.InspectMember(_Mij, "_Mij.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_Vij", &_Vij);
        R__insp.InspectMember(_Vij, "_Vij.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_VnEstij", &_VnEstij);
        R__insp.InspectMember(_VnEstij, "_VnEstij.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_dnCidnEj", &_dnCidnEj);
        R__insp.InspectMember(_dnCidnEj, "_dnCidnEj.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_dnCidPjk", &_dnCidPjk);
        R__insp.InspectMember(_dnCidPjk, "_dnCidPjk.");
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldBayes(void *p) {
        return  p ? new(p) ::RooUnfoldBayes : new ::RooUnfoldBayes;
     }
     static void *newArray_RooUnfoldBayes(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldBayes[nElements] : new ::RooUnfoldBayes[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldBayes(void *p) {
        delete ((::RooUnfoldBayes*)p);
     }
     static void deleteArray_RooUnfoldBayes(void *p) {
        delete [] ((::RooUnfoldBayes*)p);
     }
     static void destruct_RooUnfoldBayes(void *p) {
        typedef ::RooUnfoldBayes current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldBayes
  
  //______________________________________________________________________________
  void RooUnfoldBasisSplines::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldBasisSplines.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldBasisSplines::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldBasisSplines::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldBasisSplines::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldBasisSplines.
        TClass *R__cl = ::RooUnfoldBasisSplines::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_resm", &_resm);
        R__insp.InspectMember(_resm, "_resm.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nrebin", &_nrebin);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_tau", &_tau);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_m0", &_m0);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_iauto", &_iauto);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_tol", &_tol);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_measured", &_measured);
        R__insp.InspectMember(_measured, "_measured.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_reconstructed", &_reconstructed);
        R__insp.InspectMember(_reconstructed, "_reconstructed.");
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_vinv", &_vinv);
        R__insp.InspectMember(_vinv, "_vinv.");
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldBasisSplines(void *p) {
        return  p ? new(p) ::RooUnfoldBasisSplines : new ::RooUnfoldBasisSplines;
     }
     static void *newArray_RooUnfoldBasisSplines(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldBasisSplines[nElements] : new ::RooUnfoldBasisSplines[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldBasisSplines(void *p) {
        delete ((::RooUnfoldBasisSplines*)p);
     }
     static void deleteArray_RooUnfoldBasisSplines(void *p) {
        delete [] ((::RooUnfoldBasisSplines*)p);
     }
     static void destruct_RooUnfoldBasisSplines(void *p) {
        typedef ::RooUnfoldBasisSplines current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldBasisSplines
  
  //______________________________________________________________________________
  void RooUnfoldSvd::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldSvd.
        TClass *R__cl = ::RooUnfoldSvd::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_svd", &_svd);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_kreg", &_kreg);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nb", &_nb);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_meas1d", &_meas1d);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_train1d", &_train1d);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_truth1d", &_truth1d);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_reshist", &_reshist);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_meascov", &_meascov);
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldSvd(void *p) {
        return  p ? new(p) ::RooUnfoldSvd : new ::RooUnfoldSvd;
     }
     static void *newArray_RooUnfoldSvd(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldSvd[nElements] : new ::RooUnfoldSvd[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldSvd(void *p) {
        delete ((::RooUnfoldSvd*)p);
     }
     static void deleteArray_RooUnfoldSvd(void *p) {
        delete [] ((::RooUnfoldSvd*)p);
     }
     static void destruct_RooUnfoldSvd(void *p) {
        typedef ::RooUnfoldSvd current_t;
        ((current_t*)p)->~current_t();
     }
     // Wrapper around a custom streamer member function.
     static void streamer_RooUnfoldSvd(TBuffer &buf, void *obj) {
        ((::RooUnfoldSvd*)obj)->::RooUnfoldSvd::Streamer(buf);
     }
  } // end of namespace ROOTDict for class ::RooUnfoldSvd
  
  //______________________________________________________________________________
  void RooUnfoldBinByBin::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldBinByBin.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldBinByBin::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldBinByBin::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldBinByBin::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldBinByBin.
        TClass *R__cl = ::RooUnfoldBinByBin::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_factors", &_factors);
        R__insp.InspectMember(_factors, "_factors.");
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldBinByBin(void *p) {
        return  p ? new(p) ::RooUnfoldBinByBin : new ::RooUnfoldBinByBin;
     }
     static void *newArray_RooUnfoldBinByBin(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldBinByBin[nElements] : new ::RooUnfoldBinByBin[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldBinByBin(void *p) {
        delete ((::RooUnfoldBinByBin*)p);
     }
     static void deleteArray_RooUnfoldBinByBin(void *p) {
        delete [] ((::RooUnfoldBinByBin*)p);
     }
     static void destruct_RooUnfoldBinByBin(void *p) {
        typedef ::RooUnfoldBinByBin current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldBinByBin
  
  //______________________________________________________________________________
  void RooUnfoldResponse::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldResponse.
        TClass *R__cl = ::RooUnfoldResponse::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_mdim", &_mdim);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_tdim", &_tdim);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nm", &_nm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_nt", &_nt);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_mes", &_mes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_fak", &_fak);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_tru", &_tru);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_res", &_res);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_overflow", &_overflow);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_vMes", &_vMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_eMes", &_eMes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_vFak", &_vFak);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_vTru", &_vTru);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_eTru", &_eTru);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_mRes", &_mRes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_eRes", &_eRes);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_cached", &_cached);
        TNamed::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldResponse(void *p) {
        return  p ? new(p) ::RooUnfoldResponse : new ::RooUnfoldResponse;
     }
     static void *newArray_RooUnfoldResponse(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldResponse[nElements] : new ::RooUnfoldResponse[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldResponse(void *p) {
        delete ((::RooUnfoldResponse*)p);
     }
     static void deleteArray_RooUnfoldResponse(void *p) {
        delete [] ((::RooUnfoldResponse*)p);
     }
     static void destruct_RooUnfoldResponse(void *p) {
        typedef ::RooUnfoldResponse current_t;
        ((current_t*)p)->~current_t();
     }
     // Wrapper around a custom streamer member function.
     static void streamer_RooUnfoldResponse(TBuffer &buf, void *obj) {
        ((::RooUnfoldResponse*)obj)->::RooUnfoldResponse::Streamer(buf);
     }
     // Wrapper around the merge function.
     static Long64_t  merge_RooUnfoldResponse(void *obj,TCollection *coll,TFileMergeInfo *) {
        return ((::RooUnfoldResponse*)obj)->Merge(coll);
     }
  } // end of namespace ROOTDict for class ::RooUnfoldResponse
  
  //______________________________________________________________________________
  void RooUnfoldErrors::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldErrors.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldErrors::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldErrors::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldErrors::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldErrors.
        TClass *R__cl = ::RooUnfoldErrors::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "toys", &toys);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*unfold", &unfold);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hTrue", &hTrue);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*h_err", &h_err);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*h_err_res", &h_err_res);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hchi2", &hchi2);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "xlo", &xlo);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "xhi", &xhi);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "ntx", &ntx);
        TNamed::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrapper around operator delete
     static void delete_RooUnfoldErrors(void *p) {
        delete ((::RooUnfoldErrors*)p);
     }
     static void deleteArray_RooUnfoldErrors(void *p) {
        delete [] ((::RooUnfoldErrors*)p);
     }
     static void destruct_RooUnfoldErrors(void *p) {
        typedef ::RooUnfoldErrors current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldErrors
  
  //______________________________________________________________________________
  void RooUnfoldParms::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldParms.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldParms::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldParms::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldParms::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldParms.
        TClass *R__cl = ::RooUnfoldParms::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*unfold", &unfold);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "doerror", &doerror);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hTrue", &hTrue);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_done_math", &_done_math);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hrms", &hrms);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hch2", &hch2);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*herr", &herr);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*hres", &hres);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_maxparm", &_maxparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_minparm", &_minparm);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_stepsizeparm", &_stepsizeparm);
        TNamed::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldParms(void *p) {
        return  p ? new(p) ::RooUnfoldParms : new ::RooUnfoldParms;
     }
     static void *newArray_RooUnfoldParms(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldParms[nElements] : new ::RooUnfoldParms[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldParms(void *p) {
        delete ((::RooUnfoldParms*)p);
     }
     static void deleteArray_RooUnfoldParms(void *p) {
        delete [] ((::RooUnfoldParms*)p);
     }
     static void destruct_RooUnfoldParms(void *p) {
        typedef ::RooUnfoldParms current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldParms
  
  //______________________________________________________________________________
  void RooUnfoldInvert::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldInvert.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldInvert::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldInvert::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldInvert::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldInvert.
        TClass *R__cl = ::RooUnfoldInvert::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_svd", &_svd);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_resinv", &_resinv);
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldInvert(void *p) {
        return  p ? new(p) ::RooUnfoldInvert : new ::RooUnfoldInvert;
     }
     static void *newArray_RooUnfoldInvert(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldInvert[nElements] : new ::RooUnfoldInvert[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldInvert(void *p) {
        delete ((::RooUnfoldInvert*)p);
     }
     static void deleteArray_RooUnfoldInvert(void *p) {
        delete [] ((::RooUnfoldInvert*)p);
     }
     static void destruct_RooUnfoldInvert(void *p) {
        typedef ::RooUnfoldInvert current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldInvert
  
  //______________________________________________________________________________
  void RooUnfoldTUnfold::Streamer(TBuffer &R__b)
  {
     // Stream an object of class RooUnfoldTUnfold.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(RooUnfoldTUnfold::Class(),this);
     } else {
        R__b.WriteClassBuffer(RooUnfoldTUnfold::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void RooUnfoldTUnfold::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class RooUnfoldTUnfold.
        TClass *R__cl = ::RooUnfoldTUnfold::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_reg_method", &_reg_method);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_unf", &_unf);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "tau_set", &tau_set);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "_tau", &_tau);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_logTauX", &_logTauX);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_logTauY", &_logTauY);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*_lCurve", &_lCurve);
        RooUnfold::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrappers around operator new
     static void *new_RooUnfoldTUnfold(void *p) {
        return  p ? new(p) ::RooUnfoldTUnfold : new ::RooUnfoldTUnfold;
     }
     static void *newArray_RooUnfoldTUnfold(Long_t nElements, void *p) {
        return p ? new(p) ::RooUnfoldTUnfold[nElements] : new ::RooUnfoldTUnfold[nElements];
     }
     // Wrapper around operator delete
     static void delete_RooUnfoldTUnfold(void *p) {
        delete ((::RooUnfoldTUnfold*)p);
     }
     static void deleteArray_RooUnfoldTUnfold(void *p) {
        delete [] ((::RooUnfoldTUnfold*)p);
     }
     static void destruct_RooUnfoldTUnfold(void *p) {
        typedef ::RooUnfoldTUnfold current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::RooUnfoldTUnfold
  
  //______________________________________________________________________________
  void TSVDUnfold_130729::Streamer(TBuffer &R__b)
  {
     // Stream an object of class TSVDUnfold_130729.
  
     if (R__b.IsReading()) {
        R__b.ReadClassBuffer(TSVDUnfold_130729::Class(),this);
     } else {
        R__b.WriteClassBuffer(TSVDUnfold_130729::Class(),this);
     }
  }
  
  //______________________________________________________________________________
  void TSVDUnfold_130729::ShowMembers(TMemberInspector &R__insp)
  {
        // Inspect the data members of an object of class TSVDUnfold_130729.
        TClass *R__cl = ::TSVDUnfold_130729::IsA();
        if (R__cl || R__insp.IsA()) { }
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdim", &fNdim);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fDdim", &fDdim);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalize", &fNormalize);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fKReg", &fKReg);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDHist", &fDHist);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSVHist", &fSVHist);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXtau", &fXtau);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXinv", &fXinv);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBdat", &fBdat);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBcov", &fBcov);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBini", &fBini);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXini", &fXini);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAdet", &fAdet);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToyhisto", &fToyhisto);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToymat", &fToymat);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fToyMode", &fToyMode);
        R__insp.Inspect(R__cl, R__insp.GetParent(), "fMatToyMode", &fMatToyMode);
        TObject::ShowMembers(R__insp);
  }
  
  namespace ROOTDict {
     // Wrapper around operator delete
     static void delete_TSVDUnfold_130729(void *p) {
        delete ((::TSVDUnfold_130729*)p);
     }
     static void deleteArray_TSVDUnfold_130729(void *p) {
        delete [] ((::TSVDUnfold_130729*)p);
     }
     static void destruct_TSVDUnfold_130729(void *p) {
        typedef ::TSVDUnfold_130729 current_t;
        ((current_t*)p)->~current_t();
     }
  } // end of namespace ROOTDict for class ::TSVDUnfold_130729
  
  /********************************************************
  * /hepstore/rjones/Exercises/RooUnfold/tmp/linuxx8664gcc/RooUnfoldDict.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_tagtableRooUnfoldDict();
  
  extern "C" void G__set_cpp_environmentRooUnfoldDict() {
    G__cpp_reset_tagtableRooUnfoldDict();
  }
  #include <new>
  extern "C" int G__cpp_dllrevRooUnfoldDict() { return(30051515); }
  
  /*********************************************************
  * Member function Interface Method
  *********************************************************/
  
  /* RooUnfoldResponse */
  static int G__RooUnfoldDict_280_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse[n];
       } else {
         p = new((void*) gvp) RooUnfoldResponse[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse;
       } else {
         p = new((void*) gvp) RooUnfoldResponse;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldResponse((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldResponse((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldResponse(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldResponse(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldResponse(*(RooUnfoldResponse*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldResponse(*(RooUnfoldResponse*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->operator=(*(RooUnfoldResponse*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 8:
       //m: 8
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
  , (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
  , (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
       }
       break;
     case 7:
       //m: 7
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
  , (const char*) G__int(libp->para[6]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
  , (const char*) G__int(libp->para[6]));
       }
       break;
     case 6:
       //m: 6
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldResponse* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldResponse(
  (TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Reset();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Setup(*(RooUnfoldResponse*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Setup((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Setup((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Setup((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldResponse& obj = ((RooUnfoldResponse*) G__getstructoffset())->Setup((TH1*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TH2*) G__int(libp->para[2]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 5:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
  , (Double_t) G__double(libp->para[4])));
        break;
     case 4:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 7:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill(
  (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
  , (Double_t) G__double(libp->para[6])));
        break;
     case 6:
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
  , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Miss((Double_t) G__double(libp->para[0])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Miss((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Miss((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Miss((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fake((Double_t) G__double(libp->para[0])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fake((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fake((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((RooUnfoldResponse*) G__getstructoffset())->Fake((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldResponse*) G__getstructoffset())->Add(*(RooUnfoldResponse*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letLonglong(result7, 110, (G__int64) ((RooUnfoldResponse*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldResponse*) G__getstructoffset())->GetDimensionMeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldResponse*) G__getstructoffset())->GetDimensionTruth());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldResponse*) G__getstructoffset())->GetNbinsMeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldResponse*) G__getstructoffset())->GetNbinsTruth());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->Hmeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldResponse*) G__getstructoffset())->Hmeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->Hfakes());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldResponse*) G__getstructoffset())->Hfakes());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->Htruth());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldResponse*) G__getstructoffset())->Htruth());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->Hresponse());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldResponse*) G__getstructoffset())->Hresponse());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->HresponseNoOverflow());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Vmeasured();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Emeasured();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Vfakes();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Vtruth();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Etruth();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TMatrixD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Mresponse();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TMatrixD& obj = ((const RooUnfoldResponse*) G__getstructoffset())->Eresponse();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfoldResponse*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        ((RooUnfoldResponse*) G__getstructoffset())->UseOverflow((Bool_t) G__int(libp->para[0]));
        G__setnull(result7);
        break;
     case 0:
        ((RooUnfoldResponse*) G__getstructoffset())->UseOverflow();
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 103, (long) ((const RooUnfoldResponse*) G__getstructoffset())->UseOverflowStatus());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfoldResponse*) G__getstructoffset())->FakeEntries());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldResponse::H2H1D((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2V((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2V((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2VE((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2VE((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 5:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2M((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (Bool_t) G__int(libp->para[4])));
        break;
     case 4:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2M((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])));
        break;
     case 3:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2M((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 5:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2ME((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (Bool_t) G__int(libp->para[4])));
        break;
     case 4:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2ME((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])));
        break;
     case 3:
        G__letint(result7, 85, (long) RooUnfoldResponse::H2ME((TH2*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 4:
        RooUnfoldResponse::V2H(*(TVectorD*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
        G__setnull(result7);
        break;
     case 3:
        RooUnfoldResponse::V2H(*(TVectorD*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldResponse::FindBin((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldResponse::FindBin((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldResponse::FindBin((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 105, (long) RooUnfoldResponse::GetBin((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 105, (long) RooUnfoldResponse::GetBin((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letdouble(result7, 100, (double) RooUnfoldResponse::GetBinContent((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letdouble(result7, 100, (double) RooUnfoldResponse::GetBinContent((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letdouble(result7, 100, (double) RooUnfoldResponse::GetBinError((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letdouble(result7, 100, (double) RooUnfoldResponse::GetBinError((TH1*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 4:
        RooUnfoldResponse::PrintMatrix(*(TMatrixD*) libp->para[0].ref, (const char*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
        G__setnull(result7);
        break;
     case 3:
        RooUnfoldResponse::PrintMatrix(*(TMatrixD*) libp->para[0].ref, (const char*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
        G__setnull(result7);
        break;
     case 2:
        RooUnfoldResponse::PrintMatrix(*(TMatrixD*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
        G__setnull(result7);
        break;
     case 1:
        RooUnfoldResponse::PrintMatrix(*(TMatrixD*) libp->para[0].ref);
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 2:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->ApplyToTruth((TH1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
        break;
     case 1:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->ApplyToTruth((TH1*) G__int(libp->para[0])));
        break;
     case 0:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->ApplyToTruth());
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->MakeFoldingFunction((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Bool_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->MakeFoldingFunction((TF1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
        break;
     case 1:
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->MakeFoldingFunction((TF1*) G__int(libp->para[0])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldResponse*) G__getstructoffset())->RunToy());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldResponse::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldResponse::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldResponse::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldResponse::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldResponse*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldResponse::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldResponse::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldResponse::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_280_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldResponse::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldResponse G__TRooUnfoldResponse;
  static int G__RooUnfoldDict_280_0_92(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[] (RooUnfoldResponse*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldResponse*) (soff+(sizeof(RooUnfoldResponse)*i)))->~G__TRooUnfoldResponse();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldResponse*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldResponse*) (soff))->~G__TRooUnfoldResponse();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfold */
  static int G__RooUnfoldDict_281_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 6:
        G__letint(result7, 85, (long) RooUnfold::New((RooUnfold::Algorithm) G__int(libp->para[0]), (RooUnfoldResponse*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5])));
        break;
     case 5:
        G__letint(result7, 85, (long) RooUnfold::New((RooUnfold::Algorithm) G__int(libp->para[0]), (RooUnfoldResponse*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
  , (const char*) G__int(libp->para[4])));
        break;
     case 4:
        G__letint(result7, 85, (long) RooUnfold::New((RooUnfold::Algorithm) G__int(libp->para[0]), (RooUnfoldResponse*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
        break;
     case 3:
        G__letint(result7, 85, (long) RooUnfold::New((RooUnfold::Algorithm) G__int(libp->para[0]), (RooUnfoldResponse*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfold[n];
       } else {
         p = new((void*) gvp) RooUnfold[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfold;
       } else {
         p = new((void*) gvp) RooUnfold;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfold((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfold((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfold(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfold(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfold(*(RooUnfold*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfold(*(RooUnfold*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfold& obj = ((RooUnfold*) G__getstructoffset())->operator=(*(RooUnfold*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfold((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfold((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfold& obj = ((RooUnfold*) G__getstructoffset())->Setup((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetMeasured((TH1*) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetMeasured(*(TVectorD*) libp->para[0].ref, *(TMatrixD*) libp->para[1].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetMeasured(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetMeasuredCov(*(TMatrixD*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetResponse((RooUnfoldResponse*) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetResponse((RooUnfoldResponse*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->Reset();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfold*) G__getstructoffset())->response());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfold*) G__getstructoffset())->Hmeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        G__letint(result7, 85, (long) ((RooUnfold*) G__getstructoffset())->Hreco((RooUnfold::ErrorTreatment) G__int(libp->para[0])));
        break;
     case 0:
        G__letint(result7, 85, (long) ((RooUnfold*) G__getstructoffset())->Hreco());
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfold*) G__getstructoffset())->Vmeasured();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((const RooUnfold*) G__getstructoffset())->Emeasured();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TMatrixD& obj = ((const RooUnfold*) G__getstructoffset())->GetMeasuredCov();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfold*) G__getstructoffset())->HrecoMeasured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfold*) G__getstructoffset())->Chi2measured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TVectorD& obj = ((RooUnfold*) G__getstructoffset())->Vreco();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfold*) G__getstructoffset())->Ereco((RooUnfold::ErrorTreatment) G__int(libp->para[0]));
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     case 0:
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfold*) G__getstructoffset())->Ereco();
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        {
           TVectorD* pobj;
           TVectorD xobj = ((RooUnfold*) G__getstructoffset())->ErecoV((RooUnfold::ErrorTreatment) G__int(libp->para[0]));
           pobj = new TVectorD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     case 0:
        {
           TVectorD* pobj;
           TVectorD xobj = ((RooUnfold*) G__getstructoffset())->ErecoV();
           pobj = new TVectorD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfold*) G__getstructoffset())->Wreco((RooUnfold::ErrorTreatment) G__int(libp->para[0]));
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     case 0:
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfold*) G__getstructoffset())->Wreco();
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfold*) G__getstructoffset())->verbose());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetVerbose((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        ((RooUnfold*) G__getstructoffset())->IncludeSystematics((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
        break;
     case 0:
        ((RooUnfold*) G__getstructoffset())->IncludeSystematics();
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfold*) G__getstructoffset())->SystematicsIncluded());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfold*) G__getstructoffset())->NToys());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetNToys((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfold*) G__getstructoffset())->Overflow());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        ((RooUnfold*) G__getstructoffset())->PrintTable(*(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (RooUnfold::ErrorTreatment) G__int(libp->para[2]));
        G__setnull(result7);
        break;
     case 2:
        ((RooUnfold*) G__getstructoffset())->PrintTable(*(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1]));
        G__setnull(result7);
        break;
     case 1:
        ((RooUnfold*) G__getstructoffset())->PrintTable(*(ostream*) libp->para[0].ref);
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->SetRegParm((Double_t) G__double(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfold*) G__getstructoffset())->GetRegParm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 2:
        G__letdouble(result7, 100, (double) ((RooUnfold*) G__getstructoffset())->Chi2((TH1*) G__int(libp->para[0]), (RooUnfold::ErrorTreatment) G__int(libp->para[1])));
        break;
     case 1:
        G__letdouble(result7, 100, (double) ((RooUnfold*) G__getstructoffset())->Chi2((TH1*) G__int(libp->para[0])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfold*) G__getstructoffset())->GetMinParm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfold*) G__getstructoffset())->GetMaxParm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfold*) G__getstructoffset())->GetStepSizeParm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfold*) G__getstructoffset())->GetDefaultParm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfold*) G__getstructoffset())->RunToy());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 11:
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
  , (Bool_t) G__int(libp->para[8]), (RooUnfold::ErrorTreatment) G__int(libp->para[9])
  , (Double_t) G__double(libp->para[10]));
        G__setnull(result7);
        break;
     case 10:
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
  , (Bool_t) G__int(libp->para[8]), (RooUnfold::ErrorTreatment) G__int(libp->para[9]));
        G__setnull(result7);
        break;
     case 9:
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
  , (Bool_t) G__int(libp->para[8]));
        G__setnull(result7);
        break;
     case 8:
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
        G__setnull(result7);
        break;
     case 7:
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]));
        G__setnull(result7);
        break;
     case 6:
        RooUnfold::PrintTable(*(ostream*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]), (TH1*) G__int(libp->para[3])
  , (TH1*) G__int(libp->para[4]), (TH1*) G__int(libp->para[5]));
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfold::PrintTable(
  *(ostream*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
  , *(TVectorD*) libp->para[2].ref, *(TVectorD*) libp->para[3].ref
  , *(TVectorD*) libp->para[4].ref, (Int_t) G__int(libp->para[5])
  , (Int_t) G__int(libp->para[6]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfold::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfold::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfold::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfold::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfold*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfold::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfold::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfold::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_281_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfold::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfold G__TRooUnfold;
  static int G__RooUnfoldDict_281_0_78(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[] (RooUnfold*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfold*) (soff+(sizeof(RooUnfold)*i)))->~G__TRooUnfold();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfold*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfold*) (soff))->~G__TRooUnfold();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldBasisSplines */
  static int G__RooUnfoldDict_285_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBasisSplines* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines[n];
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines;
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBasisSplines* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBasisSplines((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldBasisSplines((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBasisSplines* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBasisSplines(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBasisSplines(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBasisSplines* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBasisSplines(*(RooUnfoldBasisSplines*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBasisSplines(*(RooUnfoldBasisSplines*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBasisSplines* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 9:
       //m: 9
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]), (const char*) G__int(libp->para[7])
  , (const char*) G__int(libp->para[8]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]), (const char*) G__int(libp->para[7])
  , (const char*) G__int(libp->para[8]));
       }
       break;
     case 8:
       //m: 8
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]), (const char*) G__int(libp->para[7]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]), (const char*) G__int(libp->para[7]));
       }
       break;
     case 7:
       //m: 7
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5])
  , (const Double_t) G__double(libp->para[6]));
       }
       break;
     case 6:
       //m: 6
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5]));
       }
       break;
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3])
  , (const Int_t) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const Double_t) G__double(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBasisSplines((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldBasisSplines((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldBasisSplines& obj = ((RooUnfoldBasisSplines*) G__getstructoffset())->operator=(*(RooUnfoldBasisSplines*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldBasisSplines*) G__getstructoffset())->Impl());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfoldBasisSplines*) G__getstructoffset())->makeBasisSplineMatrix(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->bfunint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
  , (Double_t) G__double(libp->para[2])));
        break;
     case 2:
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->bfunint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->bfunintegrated((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           TMatrixDSym* pobj;
           TMatrixDSym xobj = ((RooUnfoldBasisSplines*) G__getstructoffset())->makeCurvatureMatrix((Int_t) G__int(libp->para[0]));
           pobj = new TMatrixDSym(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           TVectorD* pobj;
           TVectorD xobj = ((RooUnfoldBasisSplines*) G__getstructoffset())->makeControlpoints(*(TVectorD*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
           pobj = new TVectorD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           TVectorD* pobj;
           TVectorD xobj = ((RooUnfoldBasisSplines*) G__getstructoffset())->transformV(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
           pobj = new TVectorD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->transform((Double_t) G__double(libp->para[0]), *(TVectorD*) libp->para[1].ref));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->step(*(TVectorD*) libp->para[0].ref));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->optTau(*(TVectorD*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->optTauNoise(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 6:
        G__letint(result7, 105, (long) ((RooUnfoldBasisSplines*) G__getstructoffset())->findM0noise(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
  , *(TMatrixDSym*) libp->para[2].ref, (Int_t) G__int(libp->para[3])
  , *(Double_t*) G__Doubleref(&libp->para[4]), (Int_t) G__int(libp->para[5])));
        break;
     case 5:
        G__letint(result7, 105, (long) ((RooUnfoldBasisSplines*) G__getstructoffset())->findM0noise(*(TVectorD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
  , *(TMatrixDSym*) libp->para[2].ref, (Int_t) G__int(libp->para[3])
  , *(Double_t*) G__Doubleref(&libp->para[4])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->findTauFromNoise(*(TMatrixD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
  , *(TMatrixDSym*) libp->para[2].ref, (Int_t) G__int(libp->para[3])
  , *(TVectorD*) libp->para[4].ref));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 105, (long) ((RooUnfoldBasisSplines*) G__getstructoffset())->m0FromTau((Double_t) G__double(libp->para[0]), *(TVectorD*) libp->para[1].ref
  , (Int_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 105, (long) ((RooUnfoldBasisSplines*) G__getstructoffset())->m0FromTau((Double_t) G__double(libp->para[0]), *(TVectorD*) libp->para[1].ref));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           TMatrixD* pobj;
           TMatrixD xobj = ((RooUnfoldBasisSplines*) G__getstructoffset())->makeRebinMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
           pobj = new TMatrixD(xobj);
           result7->obj.i = (long) ((void*) pobj);
           result7->ref = result7->obj.i;
           G__store_tempobject(*result7);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((RooUnfoldBasisSplines*) G__getstructoffset())->Chi2measured());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldBasisSplines::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBasisSplines::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldBasisSplines::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldBasisSplines::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldBasisSplines*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBasisSplines::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBasisSplines::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBasisSplines::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_285_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBasisSplines::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldBasisSplines G__TRooUnfoldBasisSplines;
  static int G__RooUnfoldDict_285_0_47(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[] (RooUnfoldBasisSplines*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldBasisSplines*) (soff+(sizeof(RooUnfoldBasisSplines)*i)))->~G__TRooUnfoldBasisSplines();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldBasisSplines*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldBasisSplines*) (soff))->~G__TRooUnfoldBasisSplines();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldBayes */
  static int G__RooUnfoldDict_286_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBayes* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes[n];
       } else {
         p = new((void*) gvp) RooUnfoldBayes[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes;
       } else {
         p = new((void*) gvp) RooUnfoldBayes;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBayes* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBayes((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldBayes((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBayes* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBayes(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBayes(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBayes* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBayes(*(RooUnfoldBayes*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBayes(*(RooUnfoldBayes*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldBayes& obj = ((RooUnfoldBayes*) G__getstructoffset())->operator=(*(RooUnfoldBayes*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBayes* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 6:
       //m: 6
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       } else {
         p = new((void*) gvp) RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       }
       break;
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldBayes(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBayes((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldBayes((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        ((RooUnfoldBayes*) G__getstructoffset())->SetIterations((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
        break;
     case 0:
        ((RooUnfoldBayes*) G__getstructoffset())->SetIterations();
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 1:
        ((RooUnfoldBayes*) G__getstructoffset())->SetSmoothing((Bool_t) G__int(libp->para[0]));
        G__setnull(result7);
        break;
     case 0:
        ((RooUnfoldBayes*) G__getstructoffset())->SetSmoothing();
        G__setnull(result7);
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldBayes*) G__getstructoffset())->GetIterations());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldBayes*) G__getstructoffset())->GetSmoothing());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TMatrixD& obj = ((const RooUnfoldBayes*) G__getstructoffset())->UnfoldingMatrix();
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const TMatrixD& obj = RooUnfoldBayes::H2M((TH2*) G__int(libp->para[0]), *(TMatrixD*) libp->para[1].ref
  , (Bool_t) G__int(libp->para[2]));
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldBayes::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBayes::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldBayes::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldBayes::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldBayes*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBayes::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBayes::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBayes::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_286_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBayes::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldBayes G__TRooUnfoldBayes;
  static int G__RooUnfoldDict_286_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldBayes*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldBayes*) (soff+(sizeof(RooUnfoldBayes)*i)))->~G__TRooUnfoldBayes();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldBayes*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldBayes*) (soff))->~G__TRooUnfoldBayes();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldBinByBin */
  static int G__RooUnfoldDict_287_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBinByBin* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBinByBin[n];
       } else {
         p = new((void*) gvp) RooUnfoldBinByBin[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBinByBin;
       } else {
         p = new((void*) gvp) RooUnfoldBinByBin;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBinByBin* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBinByBin((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldBinByBin((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBinByBin* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBinByBin(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBinByBin(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBinByBin* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldBinByBin(*(RooUnfoldBinByBin*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldBinByBin(*(RooUnfoldBinByBin*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldBinByBin& obj = ((RooUnfoldBinByBin*) G__getstructoffset())->operator=(*(RooUnfoldBinByBin*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldBinByBin* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBinByBin(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldBinByBin(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBinByBin(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldBinByBin(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldBinByBin((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldBinByBin((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldBinByBin*) G__getstructoffset())->Impl());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldBinByBin::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBinByBin::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldBinByBin::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldBinByBin::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldBinByBin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBinByBin::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBinByBin::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldBinByBin::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_287_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldBinByBin::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldBinByBin G__TRooUnfoldBinByBin;
  static int G__RooUnfoldDict_287_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldBinByBin*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldBinByBin*) (soff+(sizeof(RooUnfoldBinByBin)*i)))->~G__TRooUnfoldBinByBin();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldBinByBin*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldBinByBin*) (soff))->~G__TRooUnfoldBinByBin();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldErrors */
  static int G__RooUnfoldDict_289_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldErrors* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldErrors(
  (int) G__int(libp->para[0]), (RooUnfold*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldErrors(
  (int) G__int(libp->para[0]), (RooUnfold*) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldErrors((int) G__int(libp->para[0]), (RooUnfold*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldErrors((int) G__int(libp->para[0]), (RooUnfold*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldErrors*) G__getstructoffset())->Chi2());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldErrors*) G__getstructoffset())->RMSResiduals());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldErrors*) G__getstructoffset())->UnfoldingError());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldErrors::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldErrors::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldErrors::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldErrors::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldErrors*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldErrors::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldErrors::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldErrors::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_289_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldErrors::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic copy constructor
  static int G__RooUnfoldDict_289_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  
  {
     RooUnfoldErrors* p;
     void* tmp = (void*) G__int(libp->para[0]);
     p = new RooUnfoldErrors(*(RooUnfoldErrors*) tmp);
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldErrors G__TRooUnfoldErrors;
  static int G__RooUnfoldDict_289_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[] (RooUnfoldErrors*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldErrors*) (soff+(sizeof(RooUnfoldErrors)*i)))->~G__TRooUnfoldErrors();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldErrors*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldErrors*) (soff))->~G__TRooUnfoldErrors();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldInvert */
  static int G__RooUnfoldDict_291_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldInvert* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldInvert[n];
       } else {
         p = new((void*) gvp) RooUnfoldInvert[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldInvert;
       } else {
         p = new((void*) gvp) RooUnfoldInvert;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldInvert* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldInvert((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldInvert((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldInvert* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldInvert(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldInvert(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldInvert* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldInvert(*(RooUnfoldInvert*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldInvert(*(RooUnfoldInvert*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldInvert& obj = ((RooUnfoldInvert*) G__getstructoffset())->operator=(*(RooUnfoldInvert*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldInvert* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldInvert(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldInvert(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldInvert(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldInvert(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (const char*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldInvert((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldInvert((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldInvert*) G__getstructoffset())->Impl());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldInvert::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldInvert::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldInvert::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldInvert::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldInvert*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldInvert::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldInvert::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldInvert::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_291_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldInvert::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldInvert G__TRooUnfoldInvert;
  static int G__RooUnfoldDict_291_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldInvert*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldInvert*) (soff+(sizeof(RooUnfoldInvert)*i)))->~G__TRooUnfoldInvert();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldInvert*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldInvert*) (soff))->~G__TRooUnfoldInvert();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldParms */
  static int G__RooUnfoldDict_293_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldParms* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldParms(
  (RooUnfold*) G__int(libp->para[0]), (RooUnfold::ErrorTreatment) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldParms(
  (RooUnfold*) G__int(libp->para[0]), (RooUnfold::ErrorTreatment) G__int(libp->para[1])
  , (TH1*) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldParms((RooUnfold*) G__int(libp->para[0]), (RooUnfold::ErrorTreatment) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldParms((RooUnfold*) G__int(libp->para[0]), (RooUnfold::ErrorTreatment) G__int(libp->para[1]));
       }
       break;
     case 1:
       //m: 1
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldParms((RooUnfold*) G__int(libp->para[0]));
       } else {
         p = new((void*) gvp) RooUnfoldParms((RooUnfold*) G__int(libp->para[0]));
       }
       break;
     case 0:
       int n = G__getaryconstruct();
       if (n) {
         if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
           p = new RooUnfoldParms[n];
         } else {
           p = new((void*) gvp) RooUnfoldParms[n];
         }
       } else {
         if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
           p = new RooUnfoldParms;
         } else {
           p = new((void*) gvp) RooUnfoldParms;
         }
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldParms*) G__getstructoffset())->GetChi2());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldParms*) G__getstructoffset())->GetRMSError());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldParms*) G__getstructoffset())->GetMeanResiduals());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldParms*) G__getstructoffset())->GetRMSResiduals());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldParms*) G__getstructoffset())->SetMinParm((double) G__double(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldParms*) G__getstructoffset())->SetMaxParm((double) G__double(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldParms*) G__getstructoffset())->SetStepSizeParm((double) G__double(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldParms::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldParms::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldParms::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldParms::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldParms*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldParms::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldParms::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldParms::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_293_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldParms::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic copy constructor
  static int G__RooUnfoldDict_293_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  
  {
     RooUnfoldParms* p;
     void* tmp = (void*) G__int(libp->para[0]);
     p = new RooUnfoldParms(*(RooUnfoldParms*) tmp);
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldParms G__TRooUnfoldParms;
  static int G__RooUnfoldDict_293_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldParms*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldParms*) (soff+(sizeof(RooUnfoldParms)*i)))->~G__TRooUnfoldParms();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldParms*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldParms*) (soff))->~G__TRooUnfoldParms();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* TSVDUnfold_130729 */
  static int G__RooUnfoldDict_294_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     TSVDUnfold_130729* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSVDUnfold_130729(
  (TH1D*) G__int(libp->para[0]), (TH1D*) G__int(libp->para[1])
  , (TH1D*) G__int(libp->para[2]), (TH2D*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TSVDUnfold_130729(
  (TH1D*) G__int(libp->para[0]), (TH1D*) G__int(libp->para[1])
  , (TH1D*) G__int(libp->para[2]), (TH2D*) G__int(libp->para[3]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     TSVDUnfold_130729* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSVDUnfold_130729(
  (TH1D*) G__int(libp->para[0]), (TH2D*) G__int(libp->para[1])
  , (TH1D*) G__int(libp->para[2]), (TH1D*) G__int(libp->para[3])
  , (TH2D*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TSVDUnfold_130729(
  (TH1D*) G__int(libp->para[0]), (TH2D*) G__int(libp->para[1])
  , (TH1D*) G__int(libp->para[2]), (TH1D*) G__int(libp->para[3])
  , (TH2D*) G__int(libp->para[4]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     TSVDUnfold_130729* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSVDUnfold_130729(*(TSVDUnfold_130729*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TSVDUnfold_130729(*(TSVDUnfold_130729*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((TSVDUnfold_130729*) G__getstructoffset())->SetNormalize((Bool_t) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->Unfold((Int_t) G__int(libp->para[0])));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->GetUnfoldCovMatrix((TH2D*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->GetUnfoldCovMatrix((TH2D*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     switch (libp->paran) {
     case 3:
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->GetAdetCovMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
  , (TH2D*) G__int(libp->para[2])));
        break;
     case 2:
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->GetAdetCovMatrix((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
        break;
     case 1:
        G__letint(result7, 85, (long) ((TSVDUnfold_130729*) G__getstructoffset())->GetAdetCovMatrix((Int_t) G__int(libp->para[0])));
        break;
     }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetKReg());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetD());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetSV());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetXtau());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetXinv());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const TSVDUnfold_130729*) G__getstructoffset())->GetBCov());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((TSVDUnfold_130729*) G__getstructoffset())->ComputeChiSquared(*(TH1D*) libp->para[0].ref, *(TH1D*) libp->para[1].ref));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) TSVDUnfold_130729::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) TSVDUnfold_130729::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) TSVDUnfold_130729::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        TSVDUnfold_130729::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((TSVDUnfold_130729*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) TSVDUnfold_130729::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) TSVDUnfold_130729::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) TSVDUnfold_130729::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_294_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) TSVDUnfold_130729::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef TSVDUnfold_130729 G__TTSVDUnfold_130729;
  static int G__RooUnfoldDict_294_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (TSVDUnfold_130729*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((TSVDUnfold_130729*) (soff+(sizeof(TSVDUnfold_130729)*i)))->~G__TTSVDUnfold_130729();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (TSVDUnfold_130729*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((TSVDUnfold_130729*) (soff))->~G__TTSVDUnfold_130729();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldSvd */
  static int G__RooUnfoldDict_295_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd[n];
       } else {
         p = new((void*) gvp) RooUnfoldSvd[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd;
       } else {
         p = new((void*) gvp) RooUnfoldSvd;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldSvd((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldSvd((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldSvd(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldSvd(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldSvd(*(RooUnfoldSvd*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldSvd(*(RooUnfoldSvd*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldSvd& obj = ((RooUnfoldSvd*) G__getstructoffset())->operator=(*(RooUnfoldSvd*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldSvd* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 6:
       //m: 6
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       }
       break;
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldSvd(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldSvd*) G__getstructoffset())->SetKterm((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldSvd*) G__getstructoffset())->GetKterm());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldSvd*) G__getstructoffset())->Impl());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldSvd*) G__getstructoffset())->SetNtoysSVD((Int_t) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldSvd*) G__getstructoffset())->GetNtoysSVD());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldSvd::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldSvd::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldSvd::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldSvd::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldSvd*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldSvd::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldSvd::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldSvd::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_295_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldSvd::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldSvd G__TRooUnfoldSvd;
  static int G__RooUnfoldDict_295_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldSvd*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldSvd*) (soff+(sizeof(RooUnfoldSvd)*i)))->~G__TRooUnfoldSvd();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldSvd*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldSvd*) (soff))->~G__TRooUnfoldSvd();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* RooUnfoldTUnfold */
  static int G__RooUnfoldDict_319_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold[n];
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold;
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold;
       }
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldTUnfold((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooUnfoldTUnfold((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldTUnfold(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooUnfoldTUnfold(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooUnfoldTUnfold(*(RooUnfoldTUnfold*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooUnfoldTUnfold(*(RooUnfoldTUnfold*) libp->para[0].ref);
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        {
           const RooUnfoldTUnfold& obj = ((RooUnfoldTUnfold*) G__getstructoffset())->operator=(*(RooUnfoldTUnfold*) libp->para[0].ref);
           result7->ref = (long) (&obj);
           result7->obj.i = (long) (&obj);
        }
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (TUnfold::ERegMode) G__int(libp->para[2]));
       }
       break;
     case 2:
       //m: 2
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold((RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     RooUnfoldTUnfold* p = NULL;
     char* gvp = (char*) G__getgvp();
     switch (libp->paran) {
     case 6:
       //m: 6
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
       }
       break;
     case 5:
       //m: 5
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3])
  , (const char*) G__int(libp->para[4]));
       }
       break;
     case 4:
       //m: 4
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]), (TUnfold::ERegMode) G__int(libp->para[3]));
       }
       break;
     case 3:
       //m: 3
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]));
       } else {
         p = new((void*) gvp) RooUnfoldTUnfold(
  (RooUnfoldResponse*) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
  , (Double_t) G__double(libp->para[2]));
       }
       break;
     }
     result7->obj.i = (long) p;
     result7->ref = (long) p;
     G__set_tagnum(result7,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((RooUnfoldTUnfold*) G__getstructoffset())->Impl());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldTUnfold*) G__getstructoffset())->FixTau((Double_t) G__double(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldTUnfold*) G__getstructoffset())->OptimiseTau();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letdouble(result7, 100, (double) ((const RooUnfoldTUnfold*) G__getstructoffset())->GetTau());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldTUnfold*) G__getstructoffset())->GetLCurve());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldTUnfold*) G__getstructoffset())->GetLogTauX());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) ((const RooUnfoldTUnfold*) G__getstructoffset())->GetLogTauY());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldTUnfold*) G__getstructoffset())->SetRegMethod((TUnfold::ERegMode) G__int(libp->para[0]));
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) ((const RooUnfoldTUnfold*) G__getstructoffset())->GetRegMethod());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 85, (long) RooUnfoldTUnfold::Class());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldTUnfold::Class_Name());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 115, (long) RooUnfoldTUnfold::Class_Version());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        RooUnfoldTUnfold::Dictionary();
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        ((RooUnfoldTUnfold*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
        G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldTUnfold::DeclFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldTUnfold::ImplFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 67, (long) RooUnfoldTUnfold::ImplFileName());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  static int G__RooUnfoldDict_319_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
        G__letint(result7, 105, (long) RooUnfoldTUnfold::DeclFileLine());
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  // automatic destructor
  typedef RooUnfoldTUnfold G__TRooUnfoldTUnfold;
  static int G__RooUnfoldDict_319_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
  {
     char* gvp = (char*) G__getgvp();
     long soff = G__getstructoffset();
     int n = G__getaryconstruct();
     //
     //has_a_delete: 1
     //has_own_delete1arg: 0
     //has_own_delete2arg: 0
     //
     if (!soff) {
       return(1);
     }
     if (n) {
       if (gvp == (char*)G__PVOID) {
         delete[] (RooUnfoldTUnfold*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         for (int i = n - 1; i >= 0; --i) {
           ((RooUnfoldTUnfold*) (soff+(sizeof(RooUnfoldTUnfold)*i)))->~G__TRooUnfoldTUnfold();
         }
         G__setgvp((long)gvp);
       }
     } else {
       if (gvp == (char*)G__PVOID) {
         delete (RooUnfoldTUnfold*) soff;
       } else {
         G__setgvp((long) G__PVOID);
         ((RooUnfoldTUnfold*) (soff))->~G__TRooUnfoldTUnfold();
         G__setgvp((long)gvp);
       }
     }
     G__setnull(result7);
     return(1 || funcname || hash || result7 || libp) ;
  }
  
  
  /* Setting up global function */
  
  /*********************************************************
  * Member function Stub
  *********************************************************/
  
  /* RooUnfoldResponse */
  
  /* RooUnfold */
  
  /* RooUnfoldBasisSplines */
  
  /* RooUnfoldBayes */
  
  /* RooUnfoldBinByBin */
  
  /* RooUnfoldErrors */
  
  /* RooUnfoldInvert */
  
  /* RooUnfoldParms */
  
  /* TSVDUnfold_130729 */
  
  /* RooUnfoldSvd */
  
  /* RooUnfoldTUnfold */
  
  /*********************************************************
  * Global function Stub
  *********************************************************/
  
  /*********************************************************
  * Get size of pointer to member function
  *********************************************************/
  class G__Sizep2memfuncRooUnfoldDict {
   public:
    G__Sizep2memfuncRooUnfoldDict(): p(&G__Sizep2memfuncRooUnfoldDict::sizep2memfunc) {}
      size_t sizep2memfunc() { return(sizeof(p)); }
    private:
      size_t (G__Sizep2memfuncRooUnfoldDict::*p)();
  };
  
  size_t G__get_sizep2memfuncRooUnfoldDict()
  {
    G__Sizep2memfuncRooUnfoldDict a;
    G__setsizep2memfunc((int)a.sizep2memfunc());
    return((size_t)a.sizep2memfunc());
  }
  
  
  /*********************************************************
  * virtual base class offset calculation interface
  *********************************************************/
  
     /* Setting up class inheritance */
  
  /*********************************************************
  * Inheritance information setup/
  *********************************************************/
  extern "C" void G__cpp_setup_inheritanceRooUnfoldDict() {
  
     /* Setting up class inheritance */
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse))) {
       RooUnfoldResponse *G__Lderived;
       G__Lderived=(RooUnfoldResponse*)0x1000;
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold))) {
       RooUnfold *G__Lderived;
       G__Lderived=(RooUnfold*)0x1000;
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines))) {
       RooUnfoldBasisSplines *G__Lderived;
       G__Lderived=(RooUnfoldBasisSplines*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes))) {
       RooUnfoldBayes *G__Lderived;
       G__Lderived=(RooUnfoldBayes*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin))) {
       RooUnfoldBinByBin *G__Lderived;
       G__Lderived=(RooUnfoldBinByBin*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors))) {
       RooUnfoldErrors *G__Lderived;
       G__Lderived=(RooUnfoldErrors*)0x1000;
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert))) {
       RooUnfoldInvert *G__Lderived;
       G__Lderived=(RooUnfoldInvert*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms))) {
       RooUnfoldParms *G__Lderived;
       G__Lderived=(RooUnfoldParms*)0x1000;
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729))) {
       TSVDUnfold_130729 *G__Lderived;
       G__Lderived=(TSVDUnfold_130729*)0x1000;
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd))) {
       RooUnfoldSvd *G__Lderived;
       G__Lderived=(RooUnfoldSvd*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
     if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold))) {
       RooUnfoldTUnfold *G__Lderived;
       G__Lderived=(RooUnfoldTUnfold*)0x1000;
       {
         RooUnfold *G__Lpbase=(RooUnfold*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold),G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),(long)G__Lpbase-(long)G__Lderived,1,1);
       }
       {
         TNamed *G__Lpbase=(TNamed*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold),G__get_linked_tagnum(&G__RooUnfoldDictLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
       {
         TObject *G__Lpbase=(TObject*)G__Lderived;
         G__inheritance_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold),G__get_linked_tagnum(&G__RooUnfoldDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
       }
     }
  }
  
  /*********************************************************
  * typedef information setup/
  *********************************************************/
  extern "C" void G__cpp_setup_typetableRooUnfoldDict() {
  
     /* Setting up typedef entry */
     G__search_typename2("Int_t",105,-1,0,-1);
     G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
     G__search_typename2("Double_t",100,-1,0,-1);
     G__setnewtype(-1,"Double 8 bytes",0);
     G__search_typename2("Bool_t",103,-1,0,-1);
     G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
     G__search_typename2("Version_t",115,-1,0,-1);
     G__setnewtype(-1,"Class version identifier (short)",0);
     G__search_typename2("Long64_t",110,-1,0,-1);
     G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
     G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
     G__setnewtype(-1,NULL,0);
     G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
     G__setnewtype(-1,NULL,0);
     G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
     G__setnewtype(-1,NULL,0);
     G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTBaselEfloatgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTBaselEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEfloatgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TVectorD",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixD",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTRow_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTColumn_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTDiag_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTFlat_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSub_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTRowlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTColumnlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTDiaglEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTFlatlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSublEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSparseRowlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSparseDiaglEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TElementActionTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TElementPosActionTlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSymlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixDSym",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSymlEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSparselEdoublegR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
     G__setnewtype(-1,NULL,0);
     G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
     G__setnewtype(-1,NULL,0);
  }
  
  /*********************************************************
  * Data Member information setup/
  *********************************************************/
  
     /* Setting up class,struct,union tag member variable */
  
     /* RooUnfoldResponse */
  static void G__setup_memvarRooUnfoldResponse(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     { RooUnfoldResponse *p; p=(RooUnfoldResponse*)0x1000; if (p) { }
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_mdim=",0,"Number of measured  dimensions");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_tdim=",0,"Number of truth     dimensions");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_nm=",0,"Total number of measured  bins (not counting under/overflows)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_nt=",0,"Total number of truth     bins (not counting under/overflows)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"_mes=",0,"Measured histogram");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"_fak=",0,"Fakes    histogram");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"_tru=",0,"Truth    histogram");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2),-1,-1,4,"_res=",0,"Response histogram");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_overflow=",0,"Use histogram under/overflows if 1");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_vMes=",0,"! Cached measured vector");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_eMes=",0,"! Cached measured error");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_vFak=",0,"! Cached fakes    vector");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_vTru=",0,"! Cached truth    vector");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_eTru=",0,"! Cached truth    error");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"_mRes=",0,"! Cached response matrix");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"_eRes=",0,"! Cached response error");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"_cached=",0,"! We are using cached vectors/matrices");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfold */
  static void G__setup_memvarRooUnfold(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     { RooUnfold *p; p=(RooUnfold*)0x1000; if (p) { }
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)RooUnfold::kNone).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kBayes=%lldLL",(long long)RooUnfold::kBayes).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kSVD=%lldLL",(long long)RooUnfold::kSVD).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kBinByBin=%lldLL",(long long)RooUnfold::kBinByBin).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kTUnfold=%lldLL",(long long)RooUnfold::kTUnfold).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kInvert=%lldLL",(long long)RooUnfold::kInvert).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm),-1,-2,1,G__FastAllocString(2048).Format("kDagostini=%lldLL",(long long)RooUnfold::kDagostini).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-2,1,G__FastAllocString(2048).Format("kNoError=%lldLL",(long long)RooUnfold::kNoError).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-2,1,G__FastAllocString(2048).Format("kErrors=%lldLL",(long long)RooUnfold::kErrors).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-2,1,G__FastAllocString(2048).Format("kCovariance=%lldLL",(long long)RooUnfold::kCovariance).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-2,1,G__FastAllocString(2048).Format("kCovToy=%lldLL",(long long)RooUnfold::kCovToy).data(),0,(char*)NULL);
     G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-2,1,G__FastAllocString(2048).Format("kDefault=%lldLL",(long long)RooUnfold::kDefault).data(),0,(char*)NULL);
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_minparm=",0,"Minimum value to be used in RooUnfoldParms");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_maxparm=",0,"Maximum value to be used in RooUnfoldParms");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_stepsizeparm=",0,"StepSize value to be used in RooUnfoldParms");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_defaultparm=",0,"Recommended value for regularisation parameter");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_verbose=",0,"Debug print level");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_nm=",0,"Total number of measured bins (including under/overflows if _overflow set)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_nt=",0,"Total number of truth    bins (including under/overflows if _overflow set)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_overflow=",0,"Use histogram under/overflows if 1 (set from RooUnfoldResponse)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_NToys=",0,"Number of toys to be used");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_unfolded=",0,"unfolding done");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_haveCov=",0,"have _cov");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_haveWgt=",0,"have _wgt");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_have_err_mat=",0,"have _err_mat");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_fail=",0,"unfolding failed");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_haveErrors=",0,"have _variances");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"_haveCovMes=",0,"_covMes was set, not just cached");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_dosys=",0,"include systematic errors from response matrix? use _dosys=2 to exclude measurement errors");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse),-1,-1,2,"_res=",0,"Response matrix (not owned)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse),-1,-1,2,"_resmine=",0,"Owned response matrix");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,2,"_meas=",0,"Measured distribution (not owned)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,2,"_measmine=",0,"Owned measured histogram");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_rec=",0,"Reconstructed distribution");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_cov=",0,"Reconstructed distribution covariance");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_wgt=",0,"Reconstructed distribution weights (inverse of _cov)");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_variances=",0,"Error matrix diagonals");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_err_mat=",0,"Error matrix from toys");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_vMes=",0,"! Cached measured vector");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_eMes=",0,"! Cached measured error");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_covMes=",0,"Measurement covariance matrix");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_covL=",0,"! Cached lower triangular matrix for which _covMes = _covL * _covL^T.");
     G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-1,2,"_withError=",0,"type of error last calulcated");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldBasisSplines */
  static void G__setup_memvarRooUnfoldBasisSplines(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     { RooUnfoldBasisSplines *p; p=(RooUnfoldBasisSplines*)0x1000; if (p) { }
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"_resm=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_nrebin=",0,(char*)NULL);
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_tau=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_m0=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"_iauto=",0,(char*)NULL);
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_tol=",0,(char*)NULL);
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_measured=",0,(char*)NULL);
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"_reconstructed=",0,(char*)NULL);
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSymlEdoublegR),G__defined_typename("TMatrixDSym"),-1,4,"_vinv=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldBayes */
  static void G__setup_memvarRooUnfoldBayes(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     { RooUnfoldBayes *p; p=(RooUnfoldBayes*)0x1000; if (p) { }
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_niter=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_smoothit=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_nc=",0,"number of causes  (same as _nt)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_ne=",0,"number of effects (same as _nm)");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_N0C=",0,"number of events in prior");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"_nbartrue=",0,"best estimate of number of true events");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_nEstj=",0,"Number of measured events from Effect E_j");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_nCi=",0,"Number of true events from cause C_i");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_nbarCi=",0,"Estimated number of true events from cause C_i");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_efficiencyCi=",0,"efficiency for detecting cause C_i");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_P0C=",0,"prior before last iteration");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_UjInv=",0,"1 / (folded prior) from last iteration");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_Nji=",0,"mapping of causes to effects");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_Mij=",0,"unfolding matrix");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_Vij=",0,"covariance matrix");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_VnEstij=",0,"covariance matrix of effects");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_dnCidnEj=",0,"measurement error propagation matrix");
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_dnCidPjk=",0,"response error propagation matrix (stack j,k into each column)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldBinByBin */
  static void G__setup_memvarRooUnfoldBinByBin(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     { RooUnfoldBinByBin *p; p=(RooUnfoldBinByBin*)0x1000; if (p) { }
     G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"_factors=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldErrors */
  static void G__setup_memvarRooUnfoldErrors(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors));
     { RooUnfoldErrors *p; p=(RooUnfoldErrors*)0x1000; if (p) { }
     G__memvar_setup((void*)((long)(&p->toys)-(long)(p)),105,0,0,-1,-1,-1,1,"toys=",0,"Number of toys ");
     G__memvar_setup((void*)((long)(&p->unfold)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),-1,-1,1,"unfold=",0,"Input unfolding object");
     G__memvar_setup((void*)((long)(&p->hTrue)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,1,"hTrue=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"h_err=",0,"Output plot");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"h_err_res=",0,"Output plot");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TNtuple),-1,-1,4,"hchi2=",0,"Output plot ");
     G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"xlo=",0,"Minimum x-axis value ");
     G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"xhi=",0,"Maximum x-axis value");
     G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"ntx=",0,"Number of bins in true distribution");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldInvert */
  static void G__setup_memvarRooUnfoldInvert(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     { RooUnfoldInvert *p; p=(RooUnfoldInvert*)0x1000; if (p) { }
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TDecompSVD),-1,-1,2,"_svd=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"_resinv=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldParms */
  static void G__setup_memvarRooUnfoldParms(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms));
     { RooUnfoldParms *p; p=(RooUnfoldParms*)0x1000; if (p) { }
     G__memvar_setup((void*)((long)(&p->unfold)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold),-1,-1,1,"unfold=",0,"Input object from RooUnfold");
     G__memvar_setup((void*)((long)(&p->doerror)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment),-1,-1,1,"doerror=",0,"Set error calculation method");
     G__memvar_setup((void*)((long)(&p->hTrue)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,1,"hTrue=",0,"Truth Distribution");
     G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"_done_math=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1),-1,-1,4,"hrms=",0,"Output plot");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile),-1,-1,4,"hch2=",0,"Output plot");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile),-1,-1,4,"herr=",0,"Output plot");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile),-1,-1,4,"hres=",0,"Output plot");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_maxparm=",0,"Maximum parameter");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_minparm=",0,"Minimum parameter");
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_stepsizeparm=",0,"Step size");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* TSVDUnfold_130729 */
  static void G__setup_memvarTSVDUnfold_130729(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729));
     { TSVDUnfold_130729 *p; p=(TSVDUnfold_130729*)0x1000; if (p) { }
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdim=",0,"! Truth and reconstructed dimensions");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDdim=",0,"! Derivative for curvature matrix");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormalize=",0,"! Normalize unfolded spectrum to 1");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fKReg=",0,"! Regularisation parameter");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fDHist=",0,"! Distribution of d (for checking regularization)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fSVHist=",0,"! Distribution of singular values");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,4,"fXtau=",0,"! Computed regularized covariance matrix");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,4,"fXinv=",0,"! Computed inverse of covariance matrix");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fBdat=",0,"measured distribution (data)");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,4,"fBcov=",0,"covariance matrix of measured distribution (data)");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fBini=",0,"reconstructed distribution (MC)");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fXini=",0,"truth distribution (MC)");
     G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,4,"fAdet=",0,"Detector response matrix");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,4,"fToyhisto=",0,"! Toy MC histogram");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,4,"fToymat=",0,"! Toy MC detector response matrix");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fToyMode=",0,"! Internal switch for covariance matrix propagation");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatToyMode=",0,"! Internal switch for evaluation of statistical uncertainties from response matrix");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldSvd */
  static void G__setup_memvarRooUnfoldSvd(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     { RooUnfoldSvd *p; p=(RooUnfoldSvd*)0x1000; if (p) { }
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729),-1,-1,2,"_svd=",0,"! Implementation in TSVDUnfold object (no streamer)");
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_kreg=",0,(char*)NULL);
     G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"_nb=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,2,"_meas1d=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,2,"_train1d=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D),-1,-1,2,"_truth1d=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,2,"_reshist=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D),-1,-1,2,"_meascov=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  
     /* RooUnfoldTUnfold */
  static void G__setup_memvarRooUnfoldTUnfold(void) {
     G__tag_memvar_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     { RooUnfoldTUnfold *p; p=(RooUnfoldTUnfold*)0x1000; if (p) { }
     G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TUnfoldcLcLERegMode),-1,-1,4,"_reg_method=",0,"Regularisation method");
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TUnfold),-1,-1,4,"_unf=",0,"! Implementation in TUnfold object (no streamer)");
     G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"tau_set=",0,(char*)NULL);
     G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_tau=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSpline),-1,-1,4,"_logTauX=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TSpline),-1,-1,4,"_logTauY=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TGraph),-1,-1,4,"_lCurve=",0,(char*)NULL);
     G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
     }
     G__tag_memvar_reset();
  }
  
  extern "C" void G__cpp_setup_memvarRooUnfoldDict() {
  }
  /***********************************************************
  ************************************************************
  ************************************************************
  ************************************************************
  ************************************************************
  ************************************************************
  ************************************************************
  ***********************************************************/
  
  /*********************************************************
  * Member function information setup for each class
  *********************************************************/
  static void G__setup_memfuncRooUnfoldResponse(void) {
     /* RooUnfoldResponse */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse));
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldResponse' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_280_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldResponse' - 11 - rhs", "assignment operator", (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_6, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 5, 1, 1, 0, 
  "i - 'Int_t' 0 - nb d - 'Double_t' 0 - xlo "
  "d - 'Double_t' 0 - xhi C - - 10 '0' name "
  "C - - 10 '0' title", "constructor -  simple 1D case with same binning, measured vs truth", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 8, 1, 1, 0, 
  "i - 'Int_t' 0 - nm d - 'Double_t' 0 - mlo "
  "d - 'Double_t' 0 - mhi i - 'Int_t' 0 - nt "
  "d - 'Double_t' 0 - tlo d - 'Double_t' 0 - thi "
  "C - - 10 '0' name C - - 10 '0' title", "constructor -  simple 1D case", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_8, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 4, 1, 1, 0, 
  "U 'TH1' - 10 - measured U 'TH1' - 10 - truth "
  "C - - 10 '0' name C - - 10 '0' title", "constructor - measured and truth only used for shape", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldResponse",1767,G__RooUnfoldDict_280_0_9, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 5, 1, 1, 0, 
  "U 'TH1' - 10 - measured U 'TH1' - 10 - truth "
  "U 'TH2' - 10 - response C - - 10 '0' name "
  "C - - 10 '0' title", "create from already-filled histograms", (void*) NULL, 0);
     G__memfunc_setup("Reset",515,G__RooUnfoldDict_280_0_10, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 0, 1, 1, 0, "", "clear an existing object", (void*) NULL, 1);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_280_0_11, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldResponse' - 11 - rhs", "set up based on another instance", (void*) NULL, 1);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_280_0_12, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 3, 1, 1, 0, 
  "i - 'Int_t' 0 - nb d - 'Double_t' 0 - xlo "
  "d - 'Double_t' 0 - xhi", "set up simple 1D case with same binning, measured vs truth", (void*) NULL, 1);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_280_0_13, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 6, 1, 1, 0, 
  "i - 'Int_t' 0 - nm d - 'Double_t' 0 - mlo "
  "d - 'Double_t' 0 - mhi i - 'Int_t' 0 - nt "
  "d - 'Double_t' 0 - tlo d - 'Double_t' 0 - thi", "set up simple 1D case", (void*) NULL, 1);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_280_0_14, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 2, 1, 1, 0, 
  "U 'TH1' - 10 - measured U 'TH1' - 10 - truth", "set up - measured and truth only used for shape", (void*) NULL, 1);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_280_0_15, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 3, 1, 1, 0, 
  "U 'TH1' - 10 - measured U 'TH1' - 10 - truth "
  "U 'TH2' - 10 - response", "set up from already-filled histograms", (void*) NULL, 1);
     G__memfunc_setup("Fill",391,G__RooUnfoldDict_280_0_16, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - xt "
  "d - 'Double_t' 0 '1.0' w", "Fill 1D Response Matrix", (void*) NULL, 1);
     G__memfunc_setup("Fill",391,G__RooUnfoldDict_280_0_17, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - yr "
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
  "d - 'Double_t' 0 '1.0' w", "Fill 2D Response Matrix", (void*) NULL, 1);
     G__memfunc_setup("Fill",391,G__RooUnfoldDict_280_0_18, 105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - yr "
  "d - 'Double_t' 0 - zr d - 'Double_t' 0 - xt "
  "d - 'Double_t' 0 - yt d - 'Double_t' 0 - zt "
  "d - 'Double_t' 0 '1.0' w", "Fill 3D Response Matrix", (void*) NULL, 1);
     G__memfunc_setup("Miss",412,G__RooUnfoldDict_280_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xt", "Fill missed event into 1D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Miss",412,G__RooUnfoldDict_280_0_20, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 - w", "Fill missed event into 1D (with weight) or 2D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Miss",412,G__RooUnfoldDict_280_0_21, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
  "d - 'Double_t' 0 - w", "Fill missed event into 2D (with weight) or 3D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Miss",412,G__RooUnfoldDict_280_0_22, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
  "d - 'Double_t' 0 - zt d - 'Double_t' 0 - w", "Fill missed event into 3D Response Matrix", (void*) NULL, 1);
     G__memfunc_setup("Fake",375,G__RooUnfoldDict_280_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xr", "Fill fake event into 1D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Fake",375,G__RooUnfoldDict_280_0_24, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - w", "Fill fake event into 1D (with weight) or 2D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Fake",375,G__RooUnfoldDict_280_0_25, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - yr "
  "d - 'Double_t' 0 - w", "Fill fake event into 2D (with weight) or 3D Response Matrix", (void*) NULL, 0);
     G__memfunc_setup("Fake",375,G__RooUnfoldDict_280_0_26, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - yr "
  "d - 'Double_t' 0 - zr d - 'Double_t' 0 - w", "Fill fake event into 3D Response Matrix", (void*) NULL, 1);
     G__memfunc_setup("Add",265,G__RooUnfoldDict_280_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooUnfoldResponse' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Merge",496,G__RooUnfoldDict_280_0_28, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - others", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetDimensionMeasured",2044,G__RooUnfoldDict_280_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Dimensionality of the measured distribution", (void*) NULL, 0);
     G__memfunc_setup("GetDimensionTruth",1757,G__RooUnfoldDict_280_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Dimensionality of the truth distribution", (void*) NULL, 0);
     G__memfunc_setup("GetNbinsMeasured",1616,G__RooUnfoldDict_280_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Total number of bins in the measured distribution", (void*) NULL, 0);
     G__memfunc_setup("GetNbinsTruth",1329,G__RooUnfoldDict_280_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Total number of bins in the truth distribution", (void*) NULL, 0);
     G__memfunc_setup("Hmeasured",926,G__RooUnfoldDict_280_0_33, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 9, "", "Measured distribution, including fakes", (void*) NULL, 0);
     G__memfunc_setup("Hmeasured",926,G__RooUnfoldDict_280_0_34, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", "Measured distribution, including fakes", (void*) NULL, 0);
     G__memfunc_setup("Hfakes",594,G__RooUnfoldDict_280_0_35, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 9, "", "Fakes distribution", (void*) NULL, 0);
     G__memfunc_setup("Hfakes",594,G__RooUnfoldDict_280_0_36, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", "Fakes distribution", (void*) NULL, 0);
     G__memfunc_setup("Htruth",639,G__RooUnfoldDict_280_0_37, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 9, "", "Truth distribution, used for normalisation", (void*) NULL, 0);
     G__memfunc_setup("Htruth",639,G__RooUnfoldDict_280_0_38, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", "Truth distribution, used for normalisation", (void*) NULL, 0);
     G__memfunc_setup("Hresponse",951,G__RooUnfoldDict_280_0_39, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2), -1, 0, 0, 1, 1, 9, "", "Response matrix as a 2D-histogram: (x,y)=(measured,truth)", (void*) NULL, 0);
     G__memfunc_setup("Hresponse",951,G__RooUnfoldDict_280_0_40, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2), -1, 0, 0, 1, 1, 0, "", "Response matrix as a 2D-histogram: (x,y)=(measured,truth)", (void*) NULL, 0);
     G__memfunc_setup("HresponseNoOverflow",1992,G__RooUnfoldDict_280_0_41, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 0, 1, 1, 8, "", "Response matrix with under/overflow bins moved into histogram body", (void*) NULL, 0);
     G__memfunc_setup("Vmeasured",940,G__RooUnfoldDict_280_0_42, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Measured distribution as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Emeasured",923,G__RooUnfoldDict_280_0_43, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Measured distribution errors as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Vfakes",608,G__RooUnfoldDict_280_0_44, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Fakes distribution as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Vtruth",653,G__RooUnfoldDict_280_0_45, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Truth distribution as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Etruth",636,G__RooUnfoldDict_280_0_46, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Truth distribution errors as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Mresponse",956,G__RooUnfoldDict_280_0_47, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", "Response matrix as a TMatrixD: (row,column)=(measured,truth)", (void*) NULL, 0);
     G__memfunc_setup("Eresponse",948,G__RooUnfoldDict_280_0_48, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", "Response matrix errors as a TMatrixD: (row,column)=(measured,truth)", (void*) NULL, 0);
     G__memfunc_setup("operator()",957,G__RooUnfoldDict_280_0_49, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
  "i - 'Int_t' 0 - r i - 'Int_t' 0 - t", "Response matrix element (measured,truth)", (void*) NULL, 0);
     G__memfunc_setup("UseOverflow",1153,G__RooUnfoldDict_280_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' set", "Specify to use overflow bins", (void*) NULL, 0);
     G__memfunc_setup("UseOverflowStatus",1797,G__RooUnfoldDict_280_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", "Get UseOverflow setting", (void*) NULL, 0);
     G__memfunc_setup("FakeEntries",1105,G__RooUnfoldDict_280_0_52, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Return number of bins with fakes", (void*) NULL, 0);
     G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("H2H1D",311,G__RooUnfoldDict_280_0_54, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D), -1, 0, 2, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - nb", (char*)NULL, (void*) G__func2void( (TH1D* (*)(const TH1*, Int_t))(&RooUnfoldResponse::H2H1D) ), 0);
     G__memfunc_setup("H2V",208,G__RooUnfoldDict_280_0_55, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - nb "
  "g - 'Bool_t' 0 'kFALSE' overflow", (char*)NULL, (void*) G__func2void( (TVectorD* (*)(const TH1*, Int_t, Bool_t))(&RooUnfoldResponse::H2V) ), 0);
     G__memfunc_setup("H2VE",277,G__RooUnfoldDict_280_0_56, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - nb "
  "g - 'Bool_t' 0 'kFALSE' overflow", (char*)NULL, (void*) G__func2void( (TVectorD* (*)(const TH1*, Int_t, Bool_t))(&RooUnfoldResponse::H2VE) ), 0);
     G__memfunc_setup("H2M",199,G__RooUnfoldDict_280_0_57, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 5, 3, 1, 0, 
  "U 'TH2' - 10 - h i - 'Int_t' 0 - nx "
  "i - 'Int_t' 0 - ny U 'TH1' - 10 '0' norm "
  "g - 'Bool_t' 0 'kFALSE' overflow", (char*)NULL, (void*) G__func2void( (TMatrixD* (*)(const TH2*, Int_t, Int_t, const TH1*, Bool_t))(&RooUnfoldResponse::H2M) ), 0);
     G__memfunc_setup("H2ME",268,G__RooUnfoldDict_280_0_58, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 5, 3, 1, 0, 
  "U 'TH2' - 10 - h i - 'Int_t' 0 - nx "
  "i - 'Int_t' 0 - ny U 'TH1' - 10 '0' norm "
  "g - 'Bool_t' 0 'kFALSE' overflow", (char*)NULL, (void*) G__func2void( (TMatrixD* (*)(const TH2*, Int_t, Int_t, const TH1*, Bool_t))(&RooUnfoldResponse::H2ME) ), 0);
     G__memfunc_setup("V2H",208,G__RooUnfoldDict_280_0_59, 121, -1, -1, 0, 4, 3, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - v U 'TH1' - 0 - h "
  "i - 'Int_t' 0 - nb g - 'Bool_t' 0 'kFALSE' overflow", (char*)NULL, (void*) G__func2void( (void (*)(const TVectorD&, TH1*, Int_t, Bool_t))(&RooUnfoldResponse::V2H) ), 0);
     G__memfunc_setup("FindBin",666,G__RooUnfoldDict_280_0_60, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
  "U 'TH1' - 10 - h d - 'Double_t' 0 - x", "return vector index for bin containing (x)", (void*) G__func2void( (Int_t (*)(const TH1*, Double_t))(&RooUnfoldResponse::FindBin) ), 0);
     G__memfunc_setup("FindBin",666,G__RooUnfoldDict_280_0_61, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h d - 'Double_t' 0 - x "
  "d - 'Double_t' 0 - y", "return vector index for bin containing (x,y)", (void*) G__func2void( (Int_t (*)(const TH1*, Double_t, Double_t))(&RooUnfoldResponse::FindBin) ), 0);
     G__memfunc_setup("FindBin",666,G__RooUnfoldDict_280_0_62, 105, -1, G__defined_typename("Int_t"), 0, 4, 3, 1, 0, 
  "U 'TH1' - 10 - h d - 'Double_t' 0 - x "
  "d - 'Double_t' 0 - y d - 'Double_t' 0 - z", "return vector index for bin containing (x,y,z)", (void*) G__func2void( (Int_t (*)(const TH1*, Double_t, Double_t, Double_t))(&RooUnfoldResponse::FindBin) ), 0);
     G__memfunc_setup("GetBin",569,G__RooUnfoldDict_280_0_63, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - i "
  "g - 'Bool_t' 0 'kFALSE' overflow", "vector index (0..nx*ny-1) -> multi-dimensional histogram global bin number (0..(nx+2)*(ny+2)-1) skipping under/overflow bins", (void*) G__func2void( (Int_t (*)(const TH1*, Int_t, Bool_t))(&RooUnfoldResponse::GetBin) ), 0);
     G__memfunc_setup("GetBinContent",1300,G__RooUnfoldDict_280_0_64, 100, -1, G__defined_typename("Double_t"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - i "
  "g - 'Bool_t' 0 'kFALSE' overflow", "Bin content by vector index", (void*) G__func2void( (Double_t (*)(const TH1*, Int_t, Bool_t))(&RooUnfoldResponse::GetBinContent) ), 0);
     G__memfunc_setup("GetBinError",1091,G__RooUnfoldDict_280_0_65, 100, -1, G__defined_typename("Double_t"), 0, 3, 3, 1, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - i "
  "g - 'Bool_t' 0 'kFALSE' overflow", "Bin error   by vector index", (void*) G__func2void( (Double_t (*)(const TH1*, Int_t, Bool_t))(&RooUnfoldResponse::GetBinError) ), 0);
     G__memfunc_setup("PrintMatrix",1154,G__RooUnfoldDict_280_0_66, 121, -1, -1, 0, 4, 3, 1, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - m C - - 10 '\"matrix\"' name "
  "C - - 10 '0' format i - 'Int_t' 0 '10' cols_per_sheet", (char*)NULL, (void*) G__func2void( (void (*)(const TMatrixD&, const char*, const char*, Int_t))(&RooUnfoldResponse::PrintMatrix) ), 0);
     G__memfunc_setup("ApplyToTruth",1248,G__RooUnfoldDict_280_0_67, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 2, 1, 1, 8, 
  "U 'TH1' - 10 '0' truth C - - 10 '\"AppliedResponse\"' name", "If argument is 0, applies itself to its own truth", (void*) NULL, 0);
     G__memfunc_setup("MakeFoldingFunction",1927,G__RooUnfoldDict_280_0_68, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TF1), -1, 0, 3, 1, 1, 8, 
  "U 'TF1' - 0 - func d - 'Double_t' 0 '1e-12' eps "
  "g - 'Bool_t' 0 'false' verbose", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RunToy",625,G__RooUnfoldDict_280_0_69, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 1, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("ClearCache",955,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetNameTitleDefault",1908,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
  "C - - 10 '0' defname C - - 10 '0' deftitle", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Miss1D",529,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 '1.0' w", "Fill missed event into 1D Response Matrix (with weight)", (void*) NULL, 1);
     G__memfunc_setup("Miss2D",530,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
  "d - 'Double_t' 0 - xt d - 'Double_t' 0 - yt "
  "d - 'Double_t' 0 '1.0' w", "Fill missed event into 2D Response Matrix (with weight)", (void*) NULL, 1);
     G__memfunc_setup("Fake1D",492,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 '1.0' w", "Fill fake event into 1D Response Matrix (with weight)", (void*) NULL, 1);
     G__memfunc_setup("Fake2D",493,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
  "d - 'Double_t' 0 - xr d - 'Double_t' 0 - yr "
  "d - 'Double_t' 0 '1.0' w", "Fill fake event into 2D Response Matrix (with weight)", (void*) NULL, 1);
     G__memfunc_setup("GetBinDim",851,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 4, 0, 
  "U 'TH1' - 10 - h i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("ReplaceAxis",1105,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "U 'TAxis' - 0 - axis U 'TAxis' - 10 - source", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_280_0_80, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldResponse::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_280_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldResponse::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_280_0_82, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldResponse::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_280_0_83, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldResponse::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_280_0_87, 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__RooUnfoldDict_280_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldResponse::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_280_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldResponse::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_280_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldResponse::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_280_0_91, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldResponse::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldResponse", 1893, G__RooUnfoldDict_280_0_92, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfold(void) {
     /* RooUnfold */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold));
     G__memfunc_setup("New",298,G__RooUnfoldDict_281_0_1, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 6, 3, 1, 0, 
  "i 'RooUnfold::Algorithm' - 0 - alg U 'RooUnfoldResponse' - 10 - res "
  "U 'TH1' - 10 - meas d - 'Double_t' 0 '-1e30' regparm "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) G__func2void( (RooUnfold* (*)(RooUnfold::Algorithm, const RooUnfoldResponse*, const TH1*, Double_t, const char*, const char*))(&RooUnfold::New) ), 0);
     G__memfunc_setup("RooUnfold",920,G__RooUnfoldDict_281_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfold",920,G__RooUnfoldDict_281_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfold",920,G__RooUnfoldDict_281_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfold",920,G__RooUnfoldDict_281_0_5, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 1, 1, 1, 0, "u 'RooUnfold' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_281_0_6, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 1, 1, 1, 1, 0, "u 'RooUnfold' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfold",920,G__RooUnfoldDict_281_0_8, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 4, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Setup",529,G__RooUnfoldDict_281_0_9, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 1, 2, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetMeasured",1122,G__RooUnfoldDict_281_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - meas", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetMeasured",1122,G__RooUnfoldDict_281_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - meas u 'TMatrixT<double>' 'TMatrixD' 11 - cov", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetMeasured",1122,G__RooUnfoldDict_281_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - meas u 'TVectorT<double>' 'TVectorD' 11 - err", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetMeasuredCov",1418,G__RooUnfoldDict_281_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - cov", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetResponse",1147,G__RooUnfoldDict_281_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooUnfoldResponse' - 10 - res", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetResponse",1147,G__RooUnfoldDict_281_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 0 - res g - 'Bool_t' 0 - takeOwnership", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Reset",515,G__RooUnfoldDict_281_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("response",879,G__RooUnfoldDict_281_0_17, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldResponse), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Hmeasured",926,G__RooUnfoldDict_281_0_18, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Hreco",497,G__RooUnfoldDict_281_0_19, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 1, 1, 1, 0, "i 'RooUnfold::ErrorTreatment' - 0 'kErrors' withError", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Vmeasured",940,G__RooUnfoldDict_281_0_20, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Measured distribution as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("Emeasured",923,G__RooUnfoldDict_281_0_21, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", "Measured distribution errors as a TVectorD", (void*) NULL, 0);
     G__memfunc_setup("GetMeasuredCov",1406,G__RooUnfoldDict_281_0_22, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", "Measured distribution covariance matrix", (void*) NULL, 0);
     G__memfunc_setup("HrecoMeasured",1319,G__RooUnfoldDict_281_0_23, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Chi2measured",1180,G__RooUnfoldDict_281_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Vreco",511,G__RooUnfoldDict_281_0_25, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Ereco",494,G__RooUnfoldDict_281_0_26, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "i 'RooUnfold::ErrorTreatment' - 0 'kCovariance' witherror", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("ErecoV",580,G__RooUnfoldDict_281_0_27, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 1, 1, 1, 0, "i 'RooUnfold::ErrorTreatment' - 0 'kErrors' witherror", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Wreco",512,G__RooUnfoldDict_281_0_28, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "i 'RooUnfold::ErrorTreatment' - 0 'kCovariance' witherror", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("verbose",758,G__RooUnfoldDict_281_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetVerbose",1026,G__RooUnfoldDict_281_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("IncludeSystematics",1885,G__RooUnfoldDict_281_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' dosys", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SystematicsIncluded",1985,G__RooUnfoldDict_281_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("NToys",509,G__RooUnfoldDict_281_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Number of toys", (void*) NULL, 1);
     G__memfunc_setup("SetNToys",809,G__RooUnfoldDict_281_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - toys", "Set number of toys", (void*) NULL, 1);
     G__memfunc_setup("Overflow",852,G__RooUnfoldDict_281_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("PrintTable",1013,G__RooUnfoldDict_281_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
  "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o U 'TH1' - 10 '0' hTrue "
  "i 'RooUnfold::ErrorTreatment' - 0 'kDefault' withError", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetRegParm",986,G__RooUnfoldDict_281_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - parm", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetRegParm",974,G__RooUnfoldDict_281_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Get Regularisation Parameter", (void*) NULL, 1);
     G__memfunc_setup("Chi2",326,G__RooUnfoldDict_281_0_39, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "U 'TH1' - 10 - hTrue i 'RooUnfold::ErrorTreatment' - 0 'kCovariance' DoChi2", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetMinParm",980,G__RooUnfoldDict_281_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetMaxParm",982,G__RooUnfoldDict_281_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetStepSizeParm",1511,G__RooUnfoldDict_281_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetDefaultParm",1397,G__RooUnfoldDict_281_0_43, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RunToy",625,G__RooUnfoldDict_281_0_44, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfold), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("PrintTable",1013,G__RooUnfoldDict_281_0_46, 121, -1, -1, 0, 11, 3, 1, 0, 
  "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o U 'TH1' - 10 - hTrainTrue "
  "U 'TH1' - 10 - hTrain U 'TH1' - 10 - hTrue "
  "U 'TH1' - 10 - hMeas U 'TH1' - 10 - hReco "
  "i - 'Int_t' 0 '0' _nm i - 'Int_t' 0 '0' _nt "
  "g - 'Bool_t' 0 'kFALSE' _overflow i 'RooUnfold::ErrorTreatment' - 0 'kDefault' withError "
  "d - 'Double_t' 0 '-999.0' chi_squ", (char*)NULL, (void*) G__func2void( (void (*)(ostream&, const TH1*, const TH1*, const TH1*, const TH1*, const TH1*, Int_t, Int_t, Bool_t, RooUnfold::ErrorTreatment, Double_t))(&RooUnfold::PrintTable) ), 0);
     G__memfunc_setup("PrintTable",1013,G__RooUnfoldDict_281_0_47, 121, -1, -1, 0, 7, 3, 1, 0, 
  "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o u 'TVectorT<double>' 'TVectorD' 11 - vTrainTrue "
  "u 'TVectorT<double>' 'TVectorD' 11 - vTrain u 'TVectorT<double>' 'TVectorD' 11 - vMeas "
  "u 'TVectorT<double>' 'TVectorD' 11 - vReco i - 'Int_t' 0 - nm "
  "i - 'Int_t' 0 - nt", (char*)NULL, (void*) G__func2void( (void (*)(ostream&, const TVectorD&, const TVectorD&, const TVectorD&, const TVectorD&, Int_t, Int_t))(&RooUnfold::PrintTable) ), 0);
     G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooUnfold' - 11 - rhs", "implementation of assignment operator", (void*) NULL, 0);
     G__memfunc_setup("SetNameTitleDefault",1908,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetErrors",925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Get covariance matrix using errors on measured distribution", (void*) NULL, 1);
     G__memfunc_setup("GetErrMat",875,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Get covariance matrix using errors from residuals on reconstructed distribution", (void*) NULL, 1);
     G__memfunc_setup("GetWgt",594,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Get weight matrix using errors on measured distribution", (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("UnfoldWithErrors",1665,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
  "i 'RooUnfold::ErrorTreatment' - 0 - withError g - - 0 'false' getWeights", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("CutZeros",831,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 3, 2, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - ereco", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("HistNoOverflow",1449,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D), -1, 0, 2, 3, 2, 0, 
  "U 'TH1' - 10 - h g - 'Bool_t' 0 - overflow", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("ABAT",280,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 3, 3, 2, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - a u 'TMatrixT<double>' 'TMatrixD' 11 - b "
  "u 'TMatrixT<double>' 'TMatrixD' 1 - c", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("ABAT",280,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 3, 3, 2, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - a u 'TVectorT<double>' 'TVectorD' 11 - b "
  "u 'TMatrixT<double>' 'TMatrixD' 1 - c", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Resize",626,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 4, 3, 2, 0, 
  "U 'TH1' - 0 - h i - 'Int_t' 0 - nx "
  "i - 'Int_t' 0 '-1' ny i - 'Int_t' 0 '-1' nz", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("InvertMatrix",1261,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 3, 2, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - mat u 'TMatrixT<double>' 'TMatrixD' 1 - inv "
  "C - - 10 '\"matrix\"' name i - 'Int_t' 0 '1' verbose", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CopyData",789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'RooUnfold' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_281_0_66, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfold::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_281_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfold::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_281_0_68, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfold::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_281_0_69, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfold::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_281_0_73, 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__RooUnfoldDict_281_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfold::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_281_0_75, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfold::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_281_0_76, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfold::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_281_0_77, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfold::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfold", 1046, G__RooUnfoldDict_281_0_78, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldBasisSplines(void) {
     /* RooUnfoldBasisSplines */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines));
     G__memfunc_setup("RooUnfoldBasisSplines",2152,G__RooUnfoldDict_285_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBasisSplines",2152,G__RooUnfoldDict_285_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBasisSplines",2152,G__RooUnfoldDict_285_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBasisSplines",2152,G__RooUnfoldDict_285_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldBasisSplines' - 11 - -", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBasisSplines",2152,G__RooUnfoldDict_285_0_5, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 9, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "i - 'Int_t' 0 '1' nrebin d - 'Double_t' 10 '1.0e-8' tau "
  "i - 'Int_t' 10 '0' m0 i - 'Int_t' 10 '0' iauto "
  "d - 'Double_t' 10 '1.0e-12' tol C - - 10 '0' name "
  "C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_285_0_8, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBasisSplines), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldBasisSplines' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Impl",402,G__RooUnfoldDict_285_0_9, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("makeBasisSplineMatrix",2160,G__RooUnfoldDict_285_0_10, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - bins u 'TVectorT<double>' 'TVectorD' 11 - cppos", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("bfunint",758,G__RooUnfoldDict_285_0_11, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
  "d - 'Double_t' 0 - tmin d - 'Double_t' 0 - tmax "
  "d - 'Double_t' 0 '0.0' tshiftindx", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("bfunintegrated",1490,G__RooUnfoldDict_285_0_12, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "d - 'Double_t' 0 - t i - 'Int_t' 0 - isegment", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("makeCurvatureMatrix",2004,G__RooUnfoldDict_285_0_13, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - np", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("makeControlpoints",1820,G__RooUnfoldDict_285_0_14, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - bins i - 'Int_t' 0 - np", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("transformV",1074,G__RooUnfoldDict_285_0_15, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - bins u 'TVectorT<double>' 'TVectorD' 11 - cppos", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("transform",988,G__RooUnfoldDict_285_0_16, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "d - 'Double_t' 0 - t u 'TVectorT<double>' 'TVectorD' 11 - vx", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("step",444,G__RooUnfoldDict_285_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 11 - vx", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("optTau",637,G__RooUnfoldDict_285_0_18, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - eigenvalues d - 'Double_t' 0 - m0", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("optTauNoise",1147,G__RooUnfoldDict_285_0_19, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - eigenvalues u 'TVectorT<double>' 'TVectorD' 11 - qprime", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("findM0noise",1084,G__RooUnfoldDict_285_0_20, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - bins u 'TVectorT<double>' 'TVectorD' 11 - y "
  "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - Vinv i - 'Int_t' 0 - npstart "
  "d - 'Double_t' 1 - opttau i - 'Int_t' 0 '10' maxiter", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("findTauFromNoise",1629,G__RooUnfoldDict_285_0_21, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - AB u 'TVectorT<double>' 'TVectorD' 11 - y "
  "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - Vinv i - 'Int_t' 0 - np "
  "u 'TVectorT<double>' 'TVectorD' 1 - -", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("m0FromTau",859,G__RooUnfoldDict_285_0_22, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
  "d - 'Double_t' 0 - opttaunoise u 'TVectorT<double>' 'TVectorD' 11 - Cpeigenvalues "
  "i - 'Int_t' 0 '1' offset", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("makeRebinMatrix",1539,G__RooUnfoldDict_285_0_23, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 2, 1, 1, 0, 
  "i - 'Int_t' 0 - nbin i - 'Int_t' 0 - nrebin", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("PrintTable",1013,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
  "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o U 'TH1' - 10 - hTrue "
  "i 'RooUnfold::ErrorTreatment' - 0 - withError", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Hreco",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 1, 1, 1, 0, "i 'RooUnfold::ErrorTreatment' - 0 - withError", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("HrecoMeasured",1319,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetRegParm",986,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tau", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetRegParm",974,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Chi2measured",1180,G__RooUnfoldDict_285_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SubtractFakes",1330,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_285_0_35, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldBasisSplines::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_285_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBasisSplines::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_285_0_37, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldBasisSplines::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_285_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldBasisSplines::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_285_0_42, 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__RooUnfoldDict_285_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBasisSplines::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_285_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBasisSplines::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_285_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBasisSplines::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_285_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBasisSplines::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldBasisSplines", 2278, G__RooUnfoldDict_285_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldBayes(void) {
     /* RooUnfoldBayes */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes));
     G__memfunc_setup("RooUnfoldBayes",1420,G__RooUnfoldDict_286_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBayes",1420,G__RooUnfoldDict_286_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBayes",1420,G__RooUnfoldDict_286_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBayes",1420,G__RooUnfoldDict_286_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldBayes' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_286_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldBayes' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldBayes",1420,G__RooUnfoldDict_286_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBayes), -1, 0, 6, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "i - 'Int_t' 0 '4' niter g - 'Bool_t' 0 'false' smoothit "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetIterations",1358,G__RooUnfoldDict_286_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '4' niter", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetSmoothing",1252,G__RooUnfoldDict_286_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'false' smoothit", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetIterations",1346,G__RooUnfoldDict_286_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetSmoothing",1240,G__RooUnfoldDict_286_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("UnfoldingMatrix",1563,G__RooUnfoldDict_286_0_12, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetRegParm",986,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - parm", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetRegParm",974,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("H2M",199,G__RooUnfoldDict_286_0_17, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 3, 3, 1, 0, 
  "U 'TH2' - 10 - h u 'TMatrixT<double>' 'TMatrixD' 1 - m "
  "g - 'Bool_t' 0 - overflow", (char*)NULL, (void*) G__func2void( (TMatrixD& (*)(const TH2*, TMatrixD&, Bool_t))(&RooUnfoldBayes::H2M) ), 0);
     G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooUnfoldBayes' - 11 - rhs", "implementation of assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("setup",561,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("unfold",648,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("getCovariance",1339,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("smooth",666,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TVectorT<double>' 'TVectorD' 1 - PbarCi", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("getChi2",646,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 2, 8, 
  "u 'TVectorT<double>' 'TVectorD' 11 - prob1 u 'TVectorT<double>' 'TVectorD' 11 - prob2 "
  "d - 'Double_t' 0 - nevents", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CopyData",789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'RooUnfoldBayes' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_286_0_29, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldBayes::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_286_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBayes::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_286_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldBayes::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_286_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldBayes::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_286_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_286_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBayes::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_286_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBayes::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_286_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBayes::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_286_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBayes::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldBayes", 1546, G__RooUnfoldDict_286_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldBinByBin(void) {
     /* RooUnfoldBinByBin */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin));
     G__memfunc_setup("RooUnfoldBinByBin",1669,G__RooUnfoldDict_287_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBinByBin",1669,G__RooUnfoldDict_287_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBinByBin",1669,G__RooUnfoldDict_287_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldBinByBin",1669,G__RooUnfoldDict_287_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldBinByBin' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_287_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldBinByBin' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldBinByBin",1669,G__RooUnfoldDict_287_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldBinByBin), -1, 0, 4, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Impl",402,G__RooUnfoldDict_287_0_8, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_287_0_12, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldBinByBin::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_287_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBinByBin::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_287_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldBinByBin::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_287_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldBinByBin::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_287_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_287_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBinByBin::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_287_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBinByBin::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_287_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldBinByBin::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_287_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldBinByBin::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldBinByBin", 1795, G__RooUnfoldDict_287_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldErrors(void) {
     /* RooUnfoldErrors */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors));
     G__memfunc_setup("RooUnfoldErrors",1557,G__RooUnfoldDict_289_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors), -1, 0, 3, 1, 1, 0, 
  "i - - 0 - NToys U 'RooUnfold' - 0 - unfold "
  "U 'TH1' - 10 '0' Truth", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Chi2",326,G__RooUnfoldDict_289_0_2, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TNtuple), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RMSResiduals",1182,G__RooUnfoldDict_289_0_3, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("UnfoldingError",1456,G__RooUnfoldDict_289_0_4, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CreatePlots",1126,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CreatePlotsWithChi2",1864,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GraphParameters",1542,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_289_0_8, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldErrors::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_289_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldErrors::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_289_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldErrors::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_289_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldErrors::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_289_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_289_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldErrors::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_289_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldErrors::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_289_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldErrors::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_289_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldErrors::DeclFileLine) ), 0);
     // automatic copy constructor
     G__memfunc_setup("RooUnfoldErrors", 1557, G__RooUnfoldDict_289_0_20, (int) ('i'), G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldErrors), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldErrors' - 11 - -", (char*) NULL, (void*) NULL, 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldErrors", 1683, G__RooUnfoldDict_289_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldInvert(void) {
     /* RooUnfoldInvert */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert));
     G__memfunc_setup("RooUnfoldInvert",1552,G__RooUnfoldDict_291_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldInvert",1552,G__RooUnfoldDict_291_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldInvert",1552,G__RooUnfoldDict_291_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldInvert",1552,G__RooUnfoldDict_291_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldInvert' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_291_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldInvert' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldInvert",1552,G__RooUnfoldDict_291_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldInvert), -1, 0, 4, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Impl",402,G__RooUnfoldDict_291_0_9, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TDecompSVD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("InvertResponse",1479,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_291_0_15, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldInvert::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_291_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldInvert::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_291_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldInvert::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_291_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldInvert::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_291_0_22, 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__RooUnfoldDict_291_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldInvert::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_291_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldInvert::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_291_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldInvert::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_291_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldInvert::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldInvert", 1678, G__RooUnfoldDict_291_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldParms(void) {
     /* RooUnfoldParms */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms));
     G__memfunc_setup("RooUnfoldParms",1435,G__RooUnfoldDict_293_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms), -1, 0, 3, 1, 1, 0, 
  "U 'RooUnfold' - 10 '0' unfold_in i 'RooUnfold::ErrorTreatment' - 0 'RooUnfold::kCovariance' err "
  "U 'TH1' - 10 '0' truth", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetChi2",614,G__RooUnfoldDict_293_0_2, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetRMSError",1052,G__RooUnfoldDict_293_0_3, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetMeanResiduals",1613,G__RooUnfoldDict_293_0_4, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TProfile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetRMSResiduals",1470,G__RooUnfoldDict_293_0_5, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetMinParm",992,G__RooUnfoldDict_293_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - min", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetMaxParm",994,G__RooUnfoldDict_293_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - max", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetStepSizeParm",1523,G__RooUnfoldDict_293_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - size", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DoMath",573,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_293_0_11, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldParms::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_293_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldParms::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_293_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldParms::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_293_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldParms::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_293_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_293_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldParms::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_293_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldParms::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_293_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldParms::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_293_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldParms::DeclFileLine) ), 0);
     // automatic copy constructor
     G__memfunc_setup("RooUnfoldParms", 1435, G__RooUnfoldDict_293_0_23, (int) ('i'), G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldParms), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldParms' - 11 - -", (char*) NULL, (void*) NULL, 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldParms", 1561, G__RooUnfoldDict_293_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncTSVDUnfold_130729(void) {
     /* TSVDUnfold_130729 */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729));
     G__memfunc_setup("TSVDUnfold_130729",1342,G__RooUnfoldDict_294_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729), -1, 0, 4, 1, 1, 0, 
  "U 'TH1D' - 10 - bdat U 'TH1D' - 10 - bini "
  "U 'TH1D' - 10 - xini U 'TH2D' - 10 - Adet", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("TSVDUnfold_130729",1342,G__RooUnfoldDict_294_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729), -1, 0, 5, 1, 1, 0, 
  "U 'TH1D' - 10 - bdat U 'TH2D' - 0 - Bcov "
  "U 'TH1D' - 10 - bini U 'TH1D' - 10 - xini "
  "U 'TH2D' - 10 - Adet", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("TSVDUnfold_130729",1342,G__RooUnfoldDict_294_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729), -1, 0, 1, 1, 1, 0, "u 'TSVDUnfold_130729' - 11 - other", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetNormalize",1245,G__RooUnfoldDict_294_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - normalize", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,G__RooUnfoldDict_294_0_5, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kreg", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetUnfoldCovMatrix",1829,G__RooUnfoldDict_294_0_6, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 3, 1, 1, 0, 
  "U 'TH2D' - 10 - cov i - 'Int_t' 0 - ntoys "
  "i - 'Int_t' 0 '1' seed", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetAdetCovMatrix",1595,G__RooUnfoldDict_294_0_7, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 3, 1, 1, 0, 
  "i - 'Int_t' 0 - ntoys i - 'Int_t' 0 '1' seed "
  "U 'TH2D' - 10 '0' uncmat", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetKReg",649,G__RooUnfoldDict_294_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetD",356,G__RooUnfoldDict_294_0_9, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetSV",457,G__RooUnfoldDict_294_0_10, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH1D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetXtau",706,G__RooUnfoldDict_294_0_11, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetXinv",709,G__RooUnfoldDict_294_0_12, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetBCov",650,G__RooUnfoldDict_294_0_13, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TH2D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("ComputeChiSquared",1734,G__RooUnfoldDict_294_0_14, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
  "u 'TH1D' - 11 - truspec u 'TH1D' - 11 - unfspec", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("FillCurvatureMatrix",1981,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
  "u 'TMatrixT<double>' 'TMatrixD' 1 - tCurv u 'TMatrixT<double>' 'TMatrixD' 1 - tC", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetCurvature",1249,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 4, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - vec u 'TMatrixT<double>' 'TMatrixD' 11 - curv", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("InitHistos",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("H2V",208,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "U 'TH1D' - 10 - histo u 'TVectorT<double>' 'TVectorD' 1 - vec", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("H2Verr",537,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "U 'TH1D' - 10 - histo u 'TVectorT<double>' 'TVectorD' 1 - vec", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("V2H",208,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - vec u 'TH1D' - 1 - histo", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("H2M",199,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "U 'TH2D' - 10 - histo u 'TMatrixT<double>' 'TMatrixD' 1 - mat", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("M2H",199,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - mat u 'TH2D' - 1 - histo", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("MatDivVec",867,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 3, 3, 4, 0, 
  "u 'TMatrixT<double>' 'TMatrixD' 11 - mat u 'TVectorT<double>' 'TVectorD' 11 - vec "
  "i - 'Int_t' 0 '0' zero", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CompProd",804,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 3, 4, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - vec1 u 'TVectorT<double>' 'TVectorD' 11 - vec2", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("VecDiv",577,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 3, 3, 4, 0, 
  "u 'TVectorT<double>' 'TVectorD' 11 - vec1 u 'TVectorT<double>' 'TVectorD' 11 - vec2 "
  "i - 'Int_t' 0 '0' zero", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RegularisedSymMatInvert",2378,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
  "u 'TMatrixTSym<double>' 'TMatrixDSym' 1 - mat d - 'Double_t' 0 '1e-3' eps", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_294_0_27, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSVDUnfold_130729::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_294_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold_130729::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_294_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSVDUnfold_130729::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_294_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSVDUnfold_130729::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_294_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_294_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold_130729::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_294_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSVDUnfold_130729::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_294_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSVDUnfold_130729::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_294_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSVDUnfold_130729::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~TSVDUnfold_130729", 1468, G__RooUnfoldDict_294_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldSvd(void) {
     /* RooUnfoldSvd */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd));
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldSvd' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_295_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldSvd' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 5, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "i - 'Int_t' 0 '0' kreg C - - 10 '0' name "
  "C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldSvd",1221,G__RooUnfoldDict_295_0_8, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldSvd), -1, 0, 6, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "i - 'Int_t' 0 - kreg i - 'Int_t' 0 - ntoyssvd "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetKterm",815,G__RooUnfoldDict_295_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kreg", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetKterm",803,G__RooUnfoldDict_295_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetRegParm",986,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - parm", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetRegParm",974,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Impl",402,G__RooUnfoldDict_295_0_14, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSVDUnfold_130729), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetNtoysSVD",1078,G__RooUnfoldDict_295_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ntoyssvd", "no longer used", (void*) NULL, 0);
     G__memfunc_setup("GetNtoysSVD",1066,G__RooUnfoldDict_295_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "no longer used", (void*) NULL, 0);
     G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooUnfoldSvd' - 11 - rhs", "implementation of assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetWgt",594,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("CopyData",789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'RooUnfoldSvd' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_295_0_25, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldSvd::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_295_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldSvd::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_295_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldSvd::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_295_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldSvd::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_295_0_32, 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__RooUnfoldDict_295_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldSvd::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_295_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldSvd::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_295_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldSvd::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_295_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldSvd::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldSvd", 1347, G__RooUnfoldDict_295_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
     G__tag_memfunc_reset();
  }
  
  static void G__setup_memfuncRooUnfoldTUnfold(void) {
     /* RooUnfoldTUnfold */
     G__tag_memfunc_setup(G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold));
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_1, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 0, 1, 1, 0, "", "default constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_2, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 2, 1, 1, 0, 
  "C - - 10 - name C - - 10 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_3, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 2, 1, 1, 0, 
  "u 'TString' - 11 - name u 'TString' - 11 - title", "named constructor", (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_4, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 1, 1, 1, 0, "u 'RooUnfoldTUnfold' - 11 - rhs", "copy constructor", (void*) NULL, 0);
     G__memfunc_setup("operator=",937,G__RooUnfoldDict_319_0_5, 117, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 1, 1, 1, 1, 0, "u 'RooUnfoldTUnfold' - 11 - rhs", "assignment operator", (void*) NULL, 0);
     G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 1, 1, 1, 8, "C - - 10 '0' newname", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_7, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 5, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "i 'TUnfold::ERegMode' - 0 'TUnfold::kRegModeDerivative' reg C - - 10 '0' name "
  "C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("RooUnfoldTUnfold",1620,G__RooUnfoldDict_319_0_8, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_RooUnfoldTUnfold), -1, 0, 6, 1, 1, 0, 
  "U 'RooUnfoldResponse' - 10 - res U 'TH1' - 10 - meas "
  "d - 'Double_t' 0 - tau i 'TUnfold::ERegMode' - 0 'TUnfold::kRegModeDerivative' reg "
  "C - - 10 '0' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Impl",402,G__RooUnfoldDict_319_0_10, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TUnfold), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("FixTau",593,G__RooUnfoldDict_319_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tau", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("OptimiseTau",1140,G__RooUnfoldDict_319_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("SetRegParm",986,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - parm", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetTau",586,G__RooUnfoldDict_319_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetLCurve",881,G__RooUnfoldDict_319_0_15, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TGraph), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetLogTauX",964,G__RooUnfoldDict_319_0_16, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSpline), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetLogTauY",965,G__RooUnfoldDict_319_0_17, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TSpline), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetRegParm",974,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("SetRegMethod",1195,G__RooUnfoldDict_319_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TUnfold::ERegMode' - 0 - regmethod", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("GetRegMethod",1183,G__RooUnfoldDict_319_0_20, 105, G__get_linked_tagnum(&G__RooUnfoldDictLN_TUnfoldcLcLERegMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Unfold",616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetCov",584,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("GetSettings",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
     G__memfunc_setup("Assign",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooUnfoldTUnfold' - 11 - rhs", "implementation of assignment operator", (void*) NULL, 0);
     G__memfunc_setup("CopyData",789,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooUnfoldTUnfold' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("Class",502,G__RooUnfoldDict_319_0_28, 85, G__get_linked_tagnum(&G__RooUnfoldDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooUnfoldTUnfold::Class) ), 0);
     G__memfunc_setup("Class_Name",982,G__RooUnfoldDict_319_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldTUnfold::Class_Name) ), 0);
     G__memfunc_setup("Class_Version",1339,G__RooUnfoldDict_319_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooUnfoldTUnfold::Class_Version) ), 0);
     G__memfunc_setup("Dictionary",1046,G__RooUnfoldDict_319_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooUnfoldTUnfold::Dictionary) ), 0);
     G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__RooUnfoldDictLN_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__RooUnfoldDict_319_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
     G__memfunc_setup("DeclFileName",1145,G__RooUnfoldDict_319_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldTUnfold::DeclFileName) ), 0);
     G__memfunc_setup("ImplFileLine",1178,G__RooUnfoldDict_319_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldTUnfold::ImplFileLine) ), 0);
     G__memfunc_setup("ImplFileName",1171,G__RooUnfoldDict_319_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooUnfoldTUnfold::ImplFileName) ), 0);
     G__memfunc_setup("DeclFileLine",1152,G__RooUnfoldDict_319_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooUnfoldTUnfold::DeclFileLine) ), 0);
     // automatic destructor
     G__memfunc_setup("~RooUnfoldTUnfold", 1746, G__RooUnfoldDict_319_0_40, (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_memfuncRooUnfoldDict() {
  }
  
  /*********************************************************
  * 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_globalRooUnfoldDict() {
    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() {
  }
  
  static void G__cpp_setup_func19() {
  }
  
  static void G__cpp_setup_func20() {
  }
  
  static void G__cpp_setup_func21() {
  }
  
  static void G__cpp_setup_func22() {
  }
  
  static void G__cpp_setup_func23() {
  
     G__resetifuncposition();
  }
  
  extern "C" void G__cpp_setup_funcRooUnfoldDict() {
    G__cpp_setup_func0();
    G__cpp_setup_func1();
    G__cpp_setup_func2();
    G__cpp_setup_func3();
    G__cpp_setup_func4();
    G__cpp_setup_func5();
    G__cpp_setup_func6();
    G__cpp_setup_func7();
    G__cpp_setup_func8();
    G__cpp_setup_func9();
    G__cpp_setup_func10();
    G__cpp_setup_func11();
    G__cpp_setup_func12();
    G__cpp_setup_func13();
    G__cpp_setup_func14();
    G__cpp_setup_func15();
    G__cpp_setup_func16();
    G__cpp_setup_func17();
    G__cpp_setup_func18();
    G__cpp_setup_func19();
    G__cpp_setup_func20();
    G__cpp_setup_func21();
    G__cpp_setup_func22();
    G__cpp_setup_func23();
  }
  
  /*********************************************************
  * Class,struct,union,enum tag information setup
  *********************************************************/
  /* Setup class/struct taginfo */
  G__linked_taginfo G__RooUnfoldDictLN_TClass = { "TClass" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TBuffer = { "TBuffer" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TObject = { "TObject" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TNamed = { "TNamed" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TCollection = { "TCollection" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TString = { "TString" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TAxis = { "TAxis" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TF1 = { "TF1" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TH1D = { "TH1D" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TH1 = { "TH1" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TH2 = { "TH2" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TH2D = { "TH2D" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldResponse = { "RooUnfoldResponse" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfold = { "RooUnfold" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm = { "RooUnfold::Algorithm" , 101 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment = { "RooUnfold::ErrorTreatment" , 101 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldBasisSplines = { "RooUnfoldBasisSplines" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldBayes = { "RooUnfoldBayes" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldBinByBin = { "RooUnfoldBinByBin" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TNtuple = { "TNtuple" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldErrors = { "RooUnfoldErrors" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TDecompSVD = { "TDecompSVD" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldInvert = { "RooUnfoldInvert" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TProfile = { "TProfile" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldParms = { "RooUnfoldParms" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TSVDUnfold_130729 = { "TSVDUnfold_130729" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldSvd = { "RooUnfoldSvd" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TSpline = { "TSpline" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TGraph = { "TGraph" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TUnfold = { "TUnfold" , 99 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_TUnfoldcLcLERegMode = { "TUnfold::ERegMode" , 101 , -1 };
  G__linked_taginfo G__RooUnfoldDictLN_RooUnfoldTUnfold = { "RooUnfoldTUnfold" , 99 , -1 };
  
  /* Reset class/struct taginfo */
  extern "C" void G__cpp_reset_tagtableRooUnfoldDict() {
    G__RooUnfoldDictLN_TClass.tagnum = -1 ;
    G__RooUnfoldDictLN_TBuffer.tagnum = -1 ;
    G__RooUnfoldDictLN_TMemberInspector.tagnum = -1 ;
    G__RooUnfoldDictLN_TObject.tagnum = -1 ;
    G__RooUnfoldDictLN_TNamed.tagnum = -1 ;
    G__RooUnfoldDictLN_TCollection.tagnum = -1 ;
    G__RooUnfoldDictLN_TString.tagnum = -1 ;
    G__RooUnfoldDictLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
    G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
    G__RooUnfoldDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
    G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
    G__RooUnfoldDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TVectorTlEfloatgR.tagnum = -1 ;
    G__RooUnfoldDictLN_TVectorTlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TElementActionTlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSublEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
    G__RooUnfoldDictLN_TAxis.tagnum = -1 ;
    G__RooUnfoldDictLN_TF1.tagnum = -1 ;
    G__RooUnfoldDictLN_TH1D.tagnum = -1 ;
    G__RooUnfoldDictLN_TH1.tagnum = -1 ;
    G__RooUnfoldDictLN_TH2.tagnum = -1 ;
    G__RooUnfoldDictLN_TH2D.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldResponse.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfold.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldBasisSplines.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldBayes.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldBinByBin.tagnum = -1 ;
    G__RooUnfoldDictLN_TNtuple.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldErrors.tagnum = -1 ;
    G__RooUnfoldDictLN_TDecompSVD.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldInvert.tagnum = -1 ;
    G__RooUnfoldDictLN_TProfile.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldParms.tagnum = -1 ;
    G__RooUnfoldDictLN_TSVDUnfold_130729.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldSvd.tagnum = -1 ;
    G__RooUnfoldDictLN_TSpline.tagnum = -1 ;
    G__RooUnfoldDictLN_TGraph.tagnum = -1 ;
    G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
    G__RooUnfoldDictLN_TUnfold.tagnum = -1 ;
    G__RooUnfoldDictLN_TUnfoldcLcLERegMode.tagnum = -1 ;
    G__RooUnfoldDictLN_RooUnfoldTUnfold.tagnum = -1 ;
  }
  
  
  extern "C" void G__cpp_setup_tagtableRooUnfoldDict() {
  
     /* Setting up class,struct,union tag entry */
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TClass);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TBuffer);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMemberInspector);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TObject);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TNamed);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TCollection);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TString);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTBaselEfloatgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTBaselEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TVectorTlEfloatgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TVectorTlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TElementActionTlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TElementPosActionTlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTRow_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSymlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTRowlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSparselEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSparseRow_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSparseRowlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTDiag_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTColumn_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSparseDiag_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTFlat_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSub_constlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTColumnlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTDiaglEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTFlatlEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSublEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TMatrixTSparseDiaglEdoublegR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TAxis);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TF1);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TH1D);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TH1);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TH2);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TH2D);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldResponse),sizeof(RooUnfoldResponse),-1,130816,"Respose Matrix",G__setup_memvarRooUnfoldResponse,G__setup_memfuncRooUnfoldResponse);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfold),sizeof(RooUnfold),-1,130816,"Unfolding base class: implementations in RooUnfoldBayes, RooUnfoldSvd, RooUnfoldBinByBin, RooUnfoldTUnfold, and RooUnfoldInvert",G__setup_memvarRooUnfold,G__setup_memfuncRooUnfold);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldcLcLAlgorithm);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldcLcLErrorTreatment);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldBasisSplines),sizeof(RooUnfoldBasisSplines),-1,327424,(char*)NULL,G__setup_memvarRooUnfoldBasisSplines,G__setup_memfuncRooUnfoldBasisSplines);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldBayes),sizeof(RooUnfoldBayes),-1,326400,"Bayesian Unfolding",G__setup_memvarRooUnfoldBayes,G__setup_memfuncRooUnfoldBayes);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldBinByBin),sizeof(RooUnfoldBinByBin),-1,327424,"Bin-by-bin unfolding",G__setup_memvarRooUnfoldBinByBin,G__setup_memfuncRooUnfoldBinByBin);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TNtuple);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldErrors),sizeof(RooUnfoldErrors),-1,324608,"Show unfolding errors",G__setup_memvarRooUnfoldErrors,G__setup_memfuncRooUnfoldErrors);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TDecompSVD);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldInvert),sizeof(RooUnfoldInvert),-1,327424,"Unregularised unfolding",G__setup_memvarRooUnfoldInvert,G__setup_memfuncRooUnfoldInvert);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TProfile);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldParms),sizeof(RooUnfoldParms),-1,324864,"Optimisation of unfolding regularisation parameter",G__setup_memvarRooUnfoldParms,G__setup_memfuncRooUnfoldParms);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TSVDUnfold_130729),sizeof(TSVDUnfold_130729),-1,325120,"Data unfolding using Singular Value Decomposition (hep-ph/9509307)   ",G__setup_memvarTSVDUnfold_130729,G__setup_memfuncTSVDUnfold_130729);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldSvd),sizeof(RooUnfoldSvd),-1,130816,"SVD Unfolding (interface to TSVDUnfold)",G__setup_memvarRooUnfoldSvd,G__setup_memfuncRooUnfoldSvd);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TSpline);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TGraph);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TUnfold);
     G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_TUnfoldcLcLERegMode);
     G__tagtable_setup(G__get_linked_tagnum_fwd(&G__RooUnfoldDictLN_RooUnfoldTUnfold),sizeof(RooUnfoldTUnfold),-1,327424,"Interface to TUnfold",G__setup_memvarRooUnfoldTUnfold,G__setup_memfuncRooUnfoldTUnfold);
  }
  extern "C" void G__cpp_setupRooUnfoldDict(void) {
    G__check_setup_version(30051515,"G__cpp_setupRooUnfoldDict()");
    G__set_cpp_environmentRooUnfoldDict();
    G__cpp_setup_tagtableRooUnfoldDict();
  
    G__cpp_setup_inheritanceRooUnfoldDict();
  
    G__cpp_setup_typetableRooUnfoldDict();
  
    G__cpp_setup_memvarRooUnfoldDict();
  
    G__cpp_setup_memfuncRooUnfoldDict();
    G__cpp_setup_globalRooUnfoldDict();
    G__cpp_setup_funcRooUnfoldDict();
  
     if(0==G__getsizep2memfunc()) G__get_sizep2memfuncRooUnfoldDict();
    return;
  }
  class G__cpp_setup_initRooUnfoldDict {
    public:
      G__cpp_setup_initRooUnfoldDict() { G__add_setup_func("RooUnfoldDict",(G__incsetup)(&G__cpp_setupRooUnfoldDict)); G__call_setup_funcs(); }
     ~G__cpp_setup_initRooUnfoldDict() { G__remove_setup_func("RooUnfoldDict"); }
  };
  G__cpp_setup_initRooUnfoldDict G__cpp_setup_initializerRooUnfoldDict;
  
  