//
// File generated by core/utils/src/rootcint_tmp at Tue May 13 12:48:28 2014

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

#define R__DICTIONARY_FILENAME roofitdIroostatsdIsrcdIG__RooStats
#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 "G__RooStats.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

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

// START OF SHADOWS

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

namespace RooStats {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void RooStats_Dictionary();

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

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

   }
}

namespace ROOT {
   void RooStatscLcLHypoTestResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHypoTestResult(void *p = 0);
   static void *newArray_RooStatscLcLHypoTestResult(Long_t size, void *p);
   static void delete_RooStatscLcLHypoTestResult(void *p);
   static void deleteArray_RooStatscLcLHypoTestResult(void *p);
   static void destruct_RooStatscLcLHypoTestResult(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HypoTestResult*)
   {
      ::RooStats::HypoTestResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HypoTestResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HypoTestResult", ::RooStats::HypoTestResult::Class_Version(), "include/RooStats/HypoTestResult.h", 63,
                  typeid(::RooStats::HypoTestResult), DefineBehavior(ptr, ptr),
                  &::RooStats::HypoTestResult::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HypoTestResult) );
      instance.SetNew(&new_RooStatscLcLHypoTestResult);
      instance.SetNewArray(&newArray_RooStatscLcLHypoTestResult);
      instance.SetDelete(&delete_RooStatscLcLHypoTestResult);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHypoTestResult);
      instance.SetDestructor(&destruct_RooStatscLcLHypoTestResult);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HypoTestResult*)
   {
      return GenerateInitInstanceLocal((::RooStats::HypoTestResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HypoTestResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLModelConfig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLModelConfig(void *p = 0);
   static void *newArray_RooStatscLcLModelConfig(Long_t size, void *p);
   static void delete_RooStatscLcLModelConfig(void *p);
   static void deleteArray_RooStatscLcLModelConfig(void *p);
   static void destruct_RooStatscLcLModelConfig(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ModelConfig*)
   {
      ::RooStats::ModelConfig *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ModelConfig >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ModelConfig", ::RooStats::ModelConfig::Class_Version(), "include/RooStats/ModelConfig.h", 53,
                  typeid(::RooStats::ModelConfig), DefineBehavior(ptr, ptr),
                  &::RooStats::ModelConfig::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ModelConfig) );
      instance.SetNew(&new_RooStatscLcLModelConfig);
      instance.SetNewArray(&newArray_RooStatscLcLModelConfig);
      instance.SetDelete(&delete_RooStatscLcLModelConfig);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLModelConfig);
      instance.SetDestructor(&destruct_RooStatscLcLModelConfig);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ModelConfig*)
   {
      return GenerateInitInstanceLocal((::RooStats::ModelConfig*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ModelConfig*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHypoTestCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLHypoTestCalculator(void *p);
   static void deleteArray_RooStatscLcLHypoTestCalculator(void *p);
   static void destruct_RooStatscLcLHypoTestCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLTestStatistic_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLTestStatistic(void *p);
   static void deleteArray_RooStatscLcLTestStatistic(void *p);
   static void destruct_RooStatscLcLTestStatistic(void *p);

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

namespace ROOT {
   void RooStatscLcLSamplingDistribution_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSamplingDistribution(void *p = 0);
   static void *newArray_RooStatscLcLSamplingDistribution(Long_t size, void *p);
   static void delete_RooStatscLcLSamplingDistribution(void *p);
   static void deleteArray_RooStatscLcLSamplingDistribution(void *p);
   static void destruct_RooStatscLcLSamplingDistribution(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SamplingDistribution*)
   {
      ::RooStats::SamplingDistribution *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SamplingDistribution >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SamplingDistribution", ::RooStats::SamplingDistribution::Class_Version(), "include/RooStats/SamplingDistribution.h", 32,
                  typeid(::RooStats::SamplingDistribution), DefineBehavior(ptr, ptr),
                  &::RooStats::SamplingDistribution::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SamplingDistribution) );
      instance.SetNew(&new_RooStatscLcLSamplingDistribution);
      instance.SetNewArray(&newArray_RooStatscLcLSamplingDistribution);
      instance.SetDelete(&delete_RooStatscLcLSamplingDistribution);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSamplingDistribution);
      instance.SetDestructor(&destruct_RooStatscLcLSamplingDistribution);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SamplingDistribution*)
   {
      return GenerateInitInstanceLocal((::RooStats::SamplingDistribution*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SamplingDistribution*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLTestStatSampler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLTestStatSampler(void *p);
   static void deleteArray_RooStatscLcLTestStatSampler(void *p);
   static void destruct_RooStatscLcLTestStatSampler(void *p);

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

namespace ROOT {
   void RooStatscLcLHypoTestCalculatorGeneric_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLHypoTestCalculatorGeneric(void *p);
   static void deleteArray_RooStatscLcLHypoTestCalculatorGeneric(void *p);
   static void destruct_RooStatscLcLHypoTestCalculatorGeneric(void *p);

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

namespace ROOT {
   void RooStatscLcLAsymptoticCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLAsymptoticCalculator(void *p);
   static void deleteArray_RooStatscLcLAsymptoticCalculator(void *p);
   static void destruct_RooStatscLcLAsymptoticCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLConfInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLConfInterval(void *p);
   static void deleteArray_RooStatscLcLConfInterval(void *p);
   static void destruct_RooStatscLcLConfInterval(void *p);

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

namespace ROOT {
   void RooStatscLcLIntervalCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLIntervalCalculator(void *p);
   static void deleteArray_RooStatscLcLIntervalCalculator(void *p);
   static void destruct_RooStatscLcLIntervalCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLSimpleInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSimpleInterval(void *p = 0);
   static void *newArray_RooStatscLcLSimpleInterval(Long_t size, void *p);
   static void delete_RooStatscLcLSimpleInterval(void *p);
   static void deleteArray_RooStatscLcLSimpleInterval(void *p);
   static void destruct_RooStatscLcLSimpleInterval(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SimpleInterval*)
   {
      ::RooStats::SimpleInterval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SimpleInterval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SimpleInterval", ::RooStats::SimpleInterval::Class_Version(), "include/RooStats/SimpleInterval.h", 24,
                  typeid(::RooStats::SimpleInterval), DefineBehavior(ptr, ptr),
                  &::RooStats::SimpleInterval::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SimpleInterval) );
      instance.SetNew(&new_RooStatscLcLSimpleInterval);
      instance.SetNewArray(&newArray_RooStatscLcLSimpleInterval);
      instance.SetDelete(&delete_RooStatscLcLSimpleInterval);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSimpleInterval);
      instance.SetDestructor(&destruct_RooStatscLcLSimpleInterval);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SimpleInterval*)
   {
      return GenerateInitInstanceLocal((::RooStats::SimpleInterval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SimpleInterval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLBayesianCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLBayesianCalculator(void *p = 0);
   static void *newArray_RooStatscLcLBayesianCalculator(Long_t size, void *p);
   static void delete_RooStatscLcLBayesianCalculator(void *p);
   static void deleteArray_RooStatscLcLBayesianCalculator(void *p);
   static void destruct_RooStatscLcLBayesianCalculator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::BayesianCalculator*)
   {
      ::RooStats::BayesianCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::BayesianCalculator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::BayesianCalculator", ::RooStats::BayesianCalculator::Class_Version(), "include/RooStats/BayesianCalculator.h", 41,
                  typeid(::RooStats::BayesianCalculator), DefineBehavior(ptr, ptr),
                  &::RooStats::BayesianCalculator::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::BayesianCalculator) );
      instance.SetNew(&new_RooStatscLcLBayesianCalculator);
      instance.SetNewArray(&newArray_RooStatscLcLBayesianCalculator);
      instance.SetDelete(&delete_RooStatscLcLBayesianCalculator);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLBayesianCalculator);
      instance.SetDestructor(&destruct_RooStatscLcLBayesianCalculator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::BayesianCalculator*)
   {
      return GenerateInitInstanceLocal((::RooStats::BayesianCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::BayesianCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLBernsteinCorrection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLBernsteinCorrection(void *p = 0);
   static void *newArray_RooStatscLcLBernsteinCorrection(Long_t size, void *p);
   static void delete_RooStatscLcLBernsteinCorrection(void *p);
   static void deleteArray_RooStatscLcLBernsteinCorrection(void *p);
   static void destruct_RooStatscLcLBernsteinCorrection(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::BernsteinCorrection*)
   {
      ::RooStats::BernsteinCorrection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::BernsteinCorrection >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::BernsteinCorrection", ::RooStats::BernsteinCorrection::Class_Version(), "include/RooStats/BernsteinCorrection.h", 24,
                  typeid(::RooStats::BernsteinCorrection), DefineBehavior(ptr, ptr),
                  &::RooStats::BernsteinCorrection::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::BernsteinCorrection) );
      instance.SetNew(&new_RooStatscLcLBernsteinCorrection);
      instance.SetNewArray(&newArray_RooStatscLcLBernsteinCorrection);
      instance.SetDelete(&delete_RooStatscLcLBernsteinCorrection);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLBernsteinCorrection);
      instance.SetDestructor(&destruct_RooStatscLcLBernsteinCorrection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::BernsteinCorrection*)
   {
      return GenerateInitInstanceLocal((::RooStats::BernsteinCorrection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::BernsteinCorrection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLCombinedCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLCombinedCalculator(void *p);
   static void deleteArray_RooStatscLcLCombinedCalculator(void *p);
   static void destruct_RooStatscLcLCombinedCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLSamplingSummaryLookup_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSamplingSummaryLookup(void *p = 0);
   static void *newArray_RooStatscLcLSamplingSummaryLookup(Long_t size, void *p);
   static void delete_RooStatscLcLSamplingSummaryLookup(void *p);
   static void deleteArray_RooStatscLcLSamplingSummaryLookup(void *p);
   static void destruct_RooStatscLcLSamplingSummaryLookup(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SamplingSummaryLookup*)
   {
      ::RooStats::SamplingSummaryLookup *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SamplingSummaryLookup >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SamplingSummaryLookup", ::RooStats::SamplingSummaryLookup::Class_Version(), "include/RooStats/ConfidenceBelt.h", 35,
                  typeid(::RooStats::SamplingSummaryLookup), DefineBehavior(ptr, ptr),
                  &::RooStats::SamplingSummaryLookup::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SamplingSummaryLookup) );
      instance.SetNew(&new_RooStatscLcLSamplingSummaryLookup);
      instance.SetNewArray(&newArray_RooStatscLcLSamplingSummaryLookup);
      instance.SetDelete(&delete_RooStatscLcLSamplingSummaryLookup);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSamplingSummaryLookup);
      instance.SetDestructor(&destruct_RooStatscLcLSamplingSummaryLookup);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SamplingSummaryLookup*)
   {
      return GenerateInitInstanceLocal((::RooStats::SamplingSummaryLookup*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SamplingSummaryLookup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLAcceptanceRegion_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLAcceptanceRegion(void *p = 0);
   static void *newArray_RooStatscLcLAcceptanceRegion(Long_t size, void *p);
   static void delete_RooStatscLcLAcceptanceRegion(void *p);
   static void deleteArray_RooStatscLcLAcceptanceRegion(void *p);
   static void destruct_RooStatscLcLAcceptanceRegion(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::AcceptanceRegion*)
   {
      ::RooStats::AcceptanceRegion *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::AcceptanceRegion >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::AcceptanceRegion", ::RooStats::AcceptanceRegion::Class_Version(), "include/RooStats/ConfidenceBelt.h", 101,
                  typeid(::RooStats::AcceptanceRegion), DefineBehavior(ptr, ptr),
                  &::RooStats::AcceptanceRegion::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::AcceptanceRegion) );
      instance.SetNew(&new_RooStatscLcLAcceptanceRegion);
      instance.SetNewArray(&newArray_RooStatscLcLAcceptanceRegion);
      instance.SetDelete(&delete_RooStatscLcLAcceptanceRegion);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLAcceptanceRegion);
      instance.SetDestructor(&destruct_RooStatscLcLAcceptanceRegion);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::AcceptanceRegion*)
   {
      return GenerateInitInstanceLocal((::RooStats::AcceptanceRegion*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::AcceptanceRegion*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLSamplingSummary_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSamplingSummary(void *p = 0);
   static void *newArray_RooStatscLcLSamplingSummary(Long_t size, void *p);
   static void delete_RooStatscLcLSamplingSummary(void *p);
   static void deleteArray_RooStatscLcLSamplingSummary(void *p);
   static void destruct_RooStatscLcLSamplingSummary(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SamplingSummary*)
   {
      ::RooStats::SamplingSummary *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SamplingSummary >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SamplingSummary", ::RooStats::SamplingSummary::Class_Version(), "include/RooStats/ConfidenceBelt.h", 127,
                  typeid(::RooStats::SamplingSummary), DefineBehavior(ptr, ptr),
                  &::RooStats::SamplingSummary::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SamplingSummary) );
      instance.SetNew(&new_RooStatscLcLSamplingSummary);
      instance.SetNewArray(&newArray_RooStatscLcLSamplingSummary);
      instance.SetDelete(&delete_RooStatscLcLSamplingSummary);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSamplingSummary);
      instance.SetDestructor(&destruct_RooStatscLcLSamplingSummary);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SamplingSummary*)
   {
      return GenerateInitInstanceLocal((::RooStats::SamplingSummary*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SamplingSummary*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLConfidenceBelt_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLConfidenceBelt(void *p = 0);
   static void *newArray_RooStatscLcLConfidenceBelt(Long_t size, void *p);
   static void delete_RooStatscLcLConfidenceBelt(void *p);
   static void deleteArray_RooStatscLcLConfidenceBelt(void *p);
   static void destruct_RooStatscLcLConfidenceBelt(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ConfidenceBelt*)
   {
      ::RooStats::ConfidenceBelt *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ConfidenceBelt >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ConfidenceBelt", ::RooStats::ConfidenceBelt::Class_Version(), "include/RooStats/ConfidenceBelt.h", 160,
                  typeid(::RooStats::ConfidenceBelt), DefineBehavior(ptr, ptr),
                  &::RooStats::ConfidenceBelt::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ConfidenceBelt) );
      instance.SetNew(&new_RooStatscLcLConfidenceBelt);
      instance.SetNewArray(&newArray_RooStatscLcLConfidenceBelt);
      instance.SetDelete(&delete_RooStatscLcLConfidenceBelt);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLConfidenceBelt);
      instance.SetDestructor(&destruct_RooStatscLcLConfidenceBelt);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ConfidenceBelt*)
   {
      return GenerateInitInstanceLocal((::RooStats::ConfidenceBelt*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ConfidenceBelt*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLDebuggingSampler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLDebuggingSampler(void *p);
   static void deleteArray_RooStatscLcLDebuggingSampler(void *p);
   static void destruct_RooStatscLcLDebuggingSampler(void *p);

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

namespace ROOT {
   void RooStatscLcLProofConfig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLProofConfig(void *p);
   static void deleteArray_RooStatscLcLProofConfig(void *p);
   static void destruct_RooStatscLcLProofConfig(void *p);

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

namespace ROOT {
   void RooStatscLcLDetailedOutputAggregator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLDetailedOutputAggregator(void *p = 0);
   static void *newArray_RooStatscLcLDetailedOutputAggregator(Long_t size, void *p);
   static void delete_RooStatscLcLDetailedOutputAggregator(void *p);
   static void deleteArray_RooStatscLcLDetailedOutputAggregator(void *p);
   static void destruct_RooStatscLcLDetailedOutputAggregator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::DetailedOutputAggregator*)
   {
      ::RooStats::DetailedOutputAggregator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::DetailedOutputAggregator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::DetailedOutputAggregator", ::RooStats::DetailedOutputAggregator::Class_Version(), "include/RooStats/DetailedOutputAggregator.h", 44,
                  typeid(::RooStats::DetailedOutputAggregator), DefineBehavior(ptr, ptr),
                  &::RooStats::DetailedOutputAggregator::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::DetailedOutputAggregator) );
      instance.SetNew(&new_RooStatscLcLDetailedOutputAggregator);
      instance.SetNewArray(&newArray_RooStatscLcLDetailedOutputAggregator);
      instance.SetDelete(&delete_RooStatscLcLDetailedOutputAggregator);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLDetailedOutputAggregator);
      instance.SetDestructor(&destruct_RooStatscLcLDetailedOutputAggregator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::DetailedOutputAggregator*)
   {
      return GenerateInitInstanceLocal((::RooStats::DetailedOutputAggregator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::DetailedOutputAggregator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLToyMCSampler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLToyMCSampler(void *p = 0);
   static void *newArray_RooStatscLcLToyMCSampler(Long_t size, void *p);
   static void delete_RooStatscLcLToyMCSampler(void *p);
   static void deleteArray_RooStatscLcLToyMCSampler(void *p);
   static void destruct_RooStatscLcLToyMCSampler(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ToyMCSampler*)
   {
      ::RooStats::ToyMCSampler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ToyMCSampler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ToyMCSampler", ::RooStats::ToyMCSampler::Class_Version(), "include/RooStats/ToyMCSampler.h", 94,
                  typeid(::RooStats::ToyMCSampler), DefineBehavior(ptr, ptr),
                  &::RooStats::ToyMCSampler::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ToyMCSampler) );
      instance.SetNew(&new_RooStatscLcLToyMCSampler);
      instance.SetNewArray(&newArray_RooStatscLcLToyMCSampler);
      instance.SetDelete(&delete_RooStatscLcLToyMCSampler);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLToyMCSampler);
      instance.SetDestructor(&destruct_RooStatscLcLToyMCSampler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ToyMCSampler*)
   {
      return GenerateInitInstanceLocal((::RooStats::ToyMCSampler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ToyMCSampler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLDebuggingTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLDebuggingTestStat(void *p);
   static void deleteArray_RooStatscLcLDebuggingTestStat(void *p);
   static void destruct_RooStatscLcLDebuggingTestStat(void *p);

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

namespace ROOT {
   void RooStatscLcLPointSetInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLPointSetInterval(void *p = 0);
   static void *newArray_RooStatscLcLPointSetInterval(Long_t size, void *p);
   static void delete_RooStatscLcLPointSetInterval(void *p);
   static void deleteArray_RooStatscLcLPointSetInterval(void *p);
   static void destruct_RooStatscLcLPointSetInterval(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::PointSetInterval*)
   {
      ::RooStats::PointSetInterval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::PointSetInterval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::PointSetInterval", ::RooStats::PointSetInterval::Class_Version(), "include/RooStats/PointSetInterval.h", 27,
                  typeid(::RooStats::PointSetInterval), DefineBehavior(ptr, ptr),
                  &::RooStats::PointSetInterval::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::PointSetInterval) );
      instance.SetNew(&new_RooStatscLcLPointSetInterval);
      instance.SetNewArray(&newArray_RooStatscLcLPointSetInterval);
      instance.SetDelete(&delete_RooStatscLcLPointSetInterval);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLPointSetInterval);
      instance.SetDestructor(&destruct_RooStatscLcLPointSetInterval);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::PointSetInterval*)
   {
      return GenerateInitInstanceLocal((::RooStats::PointSetInterval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::PointSetInterval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLFeldmanCousins_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLFeldmanCousins(void *p);
   static void deleteArray_RooStatscLcLFeldmanCousins(void *p);
   static void destruct_RooStatscLcLFeldmanCousins(void *p);

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

namespace ROOT {
   void RooStatscLcLFrequentistCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLFrequentistCalculator(void *p);
   static void deleteArray_RooStatscLcLFrequentistCalculator(void *p);
   static void destruct_RooStatscLcLFrequentistCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLHeaviside_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHeaviside(void *p = 0);
   static void *newArray_RooStatscLcLHeaviside(Long_t size, void *p);
   static void delete_RooStatscLcLHeaviside(void *p);
   static void deleteArray_RooStatscLcLHeaviside(void *p);
   static void destruct_RooStatscLcLHeaviside(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::Heaviside*)
   {
      ::RooStats::Heaviside *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::Heaviside >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::Heaviside", ::RooStats::Heaviside::Class_Version(), "include/RooStats/Heaviside.h", 28,
                  typeid(::RooStats::Heaviside), DefineBehavior(ptr, ptr),
                  &::RooStats::Heaviside::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::Heaviside) );
      instance.SetNew(&new_RooStatscLcLHeaviside);
      instance.SetNewArray(&newArray_RooStatscLcLHeaviside);
      instance.SetDelete(&delete_RooStatscLcLHeaviside);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHeaviside);
      instance.SetDestructor(&destruct_RooStatscLcLHeaviside);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::Heaviside*)
   {
      return GenerateInitInstanceLocal((::RooStats::Heaviside*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::Heaviside*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHLFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHLFactory(void *p = 0);
   static void *newArray_RooStatscLcLHLFactory(Long_t size, void *p);
   static void delete_RooStatscLcLHLFactory(void *p);
   static void deleteArray_RooStatscLcLHLFactory(void *p);
   static void destruct_RooStatscLcLHLFactory(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HLFactory*)
   {
      ::RooStats::HLFactory *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HLFactory >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HLFactory", ::RooStats::HLFactory::Class_Version(), "include/RooStats/HLFactory.h", 31,
                  typeid(::RooStats::HLFactory), DefineBehavior(ptr, ptr),
                  &::RooStats::HLFactory::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HLFactory) );
      instance.SetNew(&new_RooStatscLcLHLFactory);
      instance.SetNewArray(&newArray_RooStatscLcLHLFactory);
      instance.SetDelete(&delete_RooStatscLcLHLFactory);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHLFactory);
      instance.SetDestructor(&destruct_RooStatscLcLHLFactory);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HLFactory*)
   {
      return GenerateInitInstanceLocal((::RooStats::HLFactory*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HLFactory*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHybridCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLHybridCalculator(void *p);
   static void deleteArray_RooStatscLcLHybridCalculator(void *p);
   static void destruct_RooStatscLcLHybridCalculator(void *p);

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

namespace ROOT {
   void RooStatscLcLHybridPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLHybridPlot(void *p);
   static void deleteArray_RooStatscLcLHybridPlot(void *p);
   static void destruct_RooStatscLcLHybridPlot(void *p);

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

namespace ROOT {
   void RooStatscLcLHybridResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHybridResult(void *p = 0);
   static void *newArray_RooStatscLcLHybridResult(Long_t size, void *p);
   static void delete_RooStatscLcLHybridResult(void *p);
   static void deleteArray_RooStatscLcLHybridResult(void *p);
   static void destruct_RooStatscLcLHybridResult(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HybridResult*)
   {
      ::RooStats::HybridResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HybridResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HybridResult", ::RooStats::HybridResult::Class_Version(), "include/RooStats/HybridResult.h", 27,
                  typeid(::RooStats::HybridResult), DefineBehavior(ptr, ptr),
                  &::RooStats::HybridResult::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HybridResult) );
      instance.SetNew(&new_RooStatscLcLHybridResult);
      instance.SetNewArray(&newArray_RooStatscLcLHybridResult);
      instance.SetDelete(&delete_RooStatscLcLHybridResult);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHybridResult);
      instance.SetDestructor(&destruct_RooStatscLcLHybridResult);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HybridResult*)
   {
      return GenerateInitInstanceLocal((::RooStats::HybridResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HybridResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHybridCalculatorOriginal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHybridCalculatorOriginal(void *p = 0);
   static void *newArray_RooStatscLcLHybridCalculatorOriginal(Long_t size, void *p);
   static void delete_RooStatscLcLHybridCalculatorOriginal(void *p);
   static void deleteArray_RooStatscLcLHybridCalculatorOriginal(void *p);
   static void destruct_RooStatscLcLHybridCalculatorOriginal(void *p);

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

namespace ROOT {
   void RooStatscLcLHypoTestInverterResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHypoTestInverterResult(void *p = 0);
   static void *newArray_RooStatscLcLHypoTestInverterResult(Long_t size, void *p);
   static void delete_RooStatscLcLHypoTestInverterResult(void *p);
   static void deleteArray_RooStatscLcLHypoTestInverterResult(void *p);
   static void destruct_RooStatscLcLHypoTestInverterResult(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HypoTestInverterResult*)
   {
      ::RooStats::HypoTestInverterResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HypoTestInverterResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HypoTestInverterResult", ::RooStats::HypoTestInverterResult::Class_Version(), "include/RooStats/HypoTestInverterResult.h", 28,
                  typeid(::RooStats::HypoTestInverterResult), DefineBehavior(ptr, ptr),
                  &::RooStats::HypoTestInverterResult::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HypoTestInverterResult) );
      instance.SetNew(&new_RooStatscLcLHypoTestInverterResult);
      instance.SetNewArray(&newArray_RooStatscLcLHypoTestInverterResult);
      instance.SetDelete(&delete_RooStatscLcLHypoTestInverterResult);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHypoTestInverterResult);
      instance.SetDestructor(&destruct_RooStatscLcLHypoTestInverterResult);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HypoTestInverterResult*)
   {
      return GenerateInitInstanceLocal((::RooStats::HypoTestInverterResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HypoTestInverterResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHypoTestInverter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHypoTestInverter(void *p = 0);
   static void *newArray_RooStatscLcLHypoTestInverter(Long_t size, void *p);
   static void delete_RooStatscLcLHypoTestInverter(void *p);
   static void deleteArray_RooStatscLcLHypoTestInverter(void *p);
   static void destruct_RooStatscLcLHypoTestInverter(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HypoTestInverter*)
   {
      ::RooStats::HypoTestInverter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HypoTestInverter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HypoTestInverter", ::RooStats::HypoTestInverter::Class_Version(), "include/RooStats/HypoTestInverter.h", 39,
                  typeid(::RooStats::HypoTestInverter), DefineBehavior(ptr, ptr),
                  &::RooStats::HypoTestInverter::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HypoTestInverter) );
      instance.SetNew(&new_RooStatscLcLHypoTestInverter);
      instance.SetNewArray(&newArray_RooStatscLcLHypoTestInverter);
      instance.SetDelete(&delete_RooStatscLcLHypoTestInverter);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHypoTestInverter);
      instance.SetDestructor(&destruct_RooStatscLcLHypoTestInverter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HypoTestInverter*)
   {
      return GenerateInitInstanceLocal((::RooStats::HypoTestInverter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HypoTestInverter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHypoTestInverterOriginal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHypoTestInverterOriginal(void *p = 0);
   static void *newArray_RooStatscLcLHypoTestInverterOriginal(Long_t size, void *p);
   static void delete_RooStatscLcLHypoTestInverterOriginal(void *p);
   static void deleteArray_RooStatscLcLHypoTestInverterOriginal(void *p);
   static void destruct_RooStatscLcLHypoTestInverterOriginal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HypoTestInverterOriginal*)
   {
      ::RooStats::HypoTestInverterOriginal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HypoTestInverterOriginal >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HypoTestInverterOriginal", ::RooStats::HypoTestInverterOriginal::Class_Version(), "include/RooStats/HypoTestInverterOriginal.h", 33,
                  typeid(::RooStats::HypoTestInverterOriginal), DefineBehavior(ptr, ptr),
                  &::RooStats::HypoTestInverterOriginal::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HypoTestInverterOriginal) );
      instance.SetNew(&new_RooStatscLcLHypoTestInverterOriginal);
      instance.SetNewArray(&newArray_RooStatscLcLHypoTestInverterOriginal);
      instance.SetDelete(&delete_RooStatscLcLHypoTestInverterOriginal);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHypoTestInverterOriginal);
      instance.SetDestructor(&destruct_RooStatscLcLHypoTestInverterOriginal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HypoTestInverterOriginal*)
   {
      return GenerateInitInstanceLocal((::RooStats::HypoTestInverterOriginal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HypoTestInverterOriginal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLSamplingDistPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSamplingDistPlot(void *p = 0);
   static void *newArray_RooStatscLcLSamplingDistPlot(Long_t size, void *p);
   static void delete_RooStatscLcLSamplingDistPlot(void *p);
   static void deleteArray_RooStatscLcLSamplingDistPlot(void *p);
   static void destruct_RooStatscLcLSamplingDistPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SamplingDistPlot*)
   {
      ::RooStats::SamplingDistPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SamplingDistPlot >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SamplingDistPlot", ::RooStats::SamplingDistPlot::Class_Version(), "include/RooStats/SamplingDistPlot.h", 34,
                  typeid(::RooStats::SamplingDistPlot), DefineBehavior(ptr, ptr),
                  &::RooStats::SamplingDistPlot::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SamplingDistPlot) );
      instance.SetNew(&new_RooStatscLcLSamplingDistPlot);
      instance.SetNewArray(&newArray_RooStatscLcLSamplingDistPlot);
      instance.SetDelete(&delete_RooStatscLcLSamplingDistPlot);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSamplingDistPlot);
      instance.SetDestructor(&destruct_RooStatscLcLSamplingDistPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SamplingDistPlot*)
   {
      return GenerateInitInstanceLocal((::RooStats::SamplingDistPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SamplingDistPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLHypoTestInverterPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLHypoTestInverterPlot(void *p);
   static void deleteArray_RooStatscLcLHypoTestInverterPlot(void *p);
   static void destruct_RooStatscLcLHypoTestInverterPlot(void *p);

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

namespace ROOT {
   void RooStatscLcLHypoTestPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLHypoTestPlot(void *p = 0);
   static void *newArray_RooStatscLcLHypoTestPlot(Long_t size, void *p);
   static void delete_RooStatscLcLHypoTestPlot(void *p);
   static void deleteArray_RooStatscLcLHypoTestPlot(void *p);
   static void destruct_RooStatscLcLHypoTestPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::HypoTestPlot*)
   {
      ::RooStats::HypoTestPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::HypoTestPlot >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::HypoTestPlot", ::RooStats::HypoTestPlot::Class_Version(), "include/RooStats/HypoTestPlot.h", 28,
                  typeid(::RooStats::HypoTestPlot), DefineBehavior(ptr, ptr),
                  &::RooStats::HypoTestPlot::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::HypoTestPlot) );
      instance.SetNew(&new_RooStatscLcLHypoTestPlot);
      instance.SetNewArray(&newArray_RooStatscLcLHypoTestPlot);
      instance.SetDelete(&delete_RooStatscLcLHypoTestPlot);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLHypoTestPlot);
      instance.SetDestructor(&destruct_RooStatscLcLHypoTestPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::HypoTestPlot*)
   {
      return GenerateInitInstanceLocal((::RooStats::HypoTestPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::HypoTestPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLLikelihoodInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLLikelihoodInterval(void *p = 0);
   static void *newArray_RooStatscLcLLikelihoodInterval(Long_t size, void *p);
   static void delete_RooStatscLcLLikelihoodInterval(void *p);
   static void deleteArray_RooStatscLcLLikelihoodInterval(void *p);
   static void destruct_RooStatscLcLLikelihoodInterval(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::LikelihoodInterval*)
   {
      ::RooStats::LikelihoodInterval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::LikelihoodInterval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::LikelihoodInterval", ::RooStats::LikelihoodInterval::Class_Version(), "include/RooStats/LikelihoodInterval.h", 41,
                  typeid(::RooStats::LikelihoodInterval), DefineBehavior(ptr, ptr),
                  &::RooStats::LikelihoodInterval::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::LikelihoodInterval) );
      instance.SetNew(&new_RooStatscLcLLikelihoodInterval);
      instance.SetNewArray(&newArray_RooStatscLcLLikelihoodInterval);
      instance.SetDelete(&delete_RooStatscLcLLikelihoodInterval);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLLikelihoodInterval);
      instance.SetDestructor(&destruct_RooStatscLcLLikelihoodInterval);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::LikelihoodInterval*)
   {
      return GenerateInitInstanceLocal((::RooStats::LikelihoodInterval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::LikelihoodInterval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLLikelihoodIntervalPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLLikelihoodIntervalPlot(void *p = 0);
   static void *newArray_RooStatscLcLLikelihoodIntervalPlot(Long_t size, void *p);
   static void delete_RooStatscLcLLikelihoodIntervalPlot(void *p);
   static void deleteArray_RooStatscLcLLikelihoodIntervalPlot(void *p);
   static void destruct_RooStatscLcLLikelihoodIntervalPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::LikelihoodIntervalPlot*)
   {
      ::RooStats::LikelihoodIntervalPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::LikelihoodIntervalPlot >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::LikelihoodIntervalPlot", ::RooStats::LikelihoodIntervalPlot::Class_Version(), "include/RooStats/LikelihoodIntervalPlot.h", 30,
                  typeid(::RooStats::LikelihoodIntervalPlot), DefineBehavior(ptr, ptr),
                  &::RooStats::LikelihoodIntervalPlot::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::LikelihoodIntervalPlot) );
      instance.SetNew(&new_RooStatscLcLLikelihoodIntervalPlot);
      instance.SetNewArray(&newArray_RooStatscLcLLikelihoodIntervalPlot);
      instance.SetDelete(&delete_RooStatscLcLLikelihoodIntervalPlot);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLLikelihoodIntervalPlot);
      instance.SetDestructor(&destruct_RooStatscLcLLikelihoodIntervalPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::LikelihoodIntervalPlot*)
   {
      return GenerateInitInstanceLocal((::RooStats::LikelihoodIntervalPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::LikelihoodIntervalPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMarkovChain_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMarkovChain(void *p = 0);
   static void *newArray_RooStatscLcLMarkovChain(Long_t size, void *p);
   static void delete_RooStatscLcLMarkovChain(void *p);
   static void deleteArray_RooStatscLcLMarkovChain(void *p);
   static void destruct_RooStatscLcLMarkovChain(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MarkovChain*)
   {
      ::RooStats::MarkovChain *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MarkovChain >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MarkovChain", ::RooStats::MarkovChain::Class_Version(), "include/RooStats/MarkovChain.h", 42,
                  typeid(::RooStats::MarkovChain), DefineBehavior(ptr, ptr),
                  &::RooStats::MarkovChain::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MarkovChain) );
      instance.SetNew(&new_RooStatscLcLMarkovChain);
      instance.SetNewArray(&newArray_RooStatscLcLMarkovChain);
      instance.SetDelete(&delete_RooStatscLcLMarkovChain);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMarkovChain);
      instance.SetDestructor(&destruct_RooStatscLcLMarkovChain);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MarkovChain*)
   {
      return GenerateInitInstanceLocal((::RooStats::MarkovChain*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MarkovChain*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMaxLikelihoodEstimateTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p = 0);
   static void *newArray_RooStatscLcLMaxLikelihoodEstimateTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p);
   static void deleteArray_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p);
   static void destruct_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MaxLikelihoodEstimateTestStat*)
   {
      ::RooStats::MaxLikelihoodEstimateTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MaxLikelihoodEstimateTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MaxLikelihoodEstimateTestStat", ::RooStats::MaxLikelihoodEstimateTestStat::Class_Version(), "include/RooStats/MaxLikelihoodEstimateTestStat.h", 44,
                  typeid(::RooStats::MaxLikelihoodEstimateTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::MaxLikelihoodEstimateTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MaxLikelihoodEstimateTestStat) );
      instance.SetNew(&new_RooStatscLcLMaxLikelihoodEstimateTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLMaxLikelihoodEstimateTestStat);
      instance.SetDelete(&delete_RooStatscLcLMaxLikelihoodEstimateTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMaxLikelihoodEstimateTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLMaxLikelihoodEstimateTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MaxLikelihoodEstimateTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::MaxLikelihoodEstimateTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MaxLikelihoodEstimateTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLProposalFunction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLProposalFunction(void *p);
   static void deleteArray_RooStatscLcLProposalFunction(void *p);
   static void destruct_RooStatscLcLProposalFunction(void *p);

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

namespace ROOT {
   void RooStatscLcLMCMCInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMCMCInterval(void *p = 0);
   static void *newArray_RooStatscLcLMCMCInterval(Long_t size, void *p);
   static void delete_RooStatscLcLMCMCInterval(void *p);
   static void deleteArray_RooStatscLcLMCMCInterval(void *p);
   static void destruct_RooStatscLcLMCMCInterval(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MCMCInterval*)
   {
      ::RooStats::MCMCInterval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MCMCInterval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MCMCInterval", ::RooStats::MCMCInterval::Class_Version(), "include/RooStats/MCMCInterval.h", 41,
                  typeid(::RooStats::MCMCInterval), DefineBehavior(ptr, ptr),
                  &::RooStats::MCMCInterval::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MCMCInterval) );
      instance.SetNew(&new_RooStatscLcLMCMCInterval);
      instance.SetNewArray(&newArray_RooStatscLcLMCMCInterval);
      instance.SetDelete(&delete_RooStatscLcLMCMCInterval);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMCMCInterval);
      instance.SetDestructor(&destruct_RooStatscLcLMCMCInterval);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MCMCInterval*)
   {
      return GenerateInitInstanceLocal((::RooStats::MCMCInterval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MCMCInterval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMCMCCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMCMCCalculator(void *p = 0);
   static void *newArray_RooStatscLcLMCMCCalculator(Long_t size, void *p);
   static void delete_RooStatscLcLMCMCCalculator(void *p);
   static void deleteArray_RooStatscLcLMCMCCalculator(void *p);
   static void destruct_RooStatscLcLMCMCCalculator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MCMCCalculator*)
   {
      ::RooStats::MCMCCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MCMCCalculator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MCMCCalculator", ::RooStats::MCMCCalculator::Class_Version(), "include/RooStats/MCMCCalculator.h", 48,
                  typeid(::RooStats::MCMCCalculator), DefineBehavior(ptr, ptr),
                  &::RooStats::MCMCCalculator::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MCMCCalculator) );
      instance.SetNew(&new_RooStatscLcLMCMCCalculator);
      instance.SetNewArray(&newArray_RooStatscLcLMCMCCalculator);
      instance.SetDelete(&delete_RooStatscLcLMCMCCalculator);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMCMCCalculator);
      instance.SetDestructor(&destruct_RooStatscLcLMCMCCalculator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MCMCCalculator*)
   {
      return GenerateInitInstanceLocal((::RooStats::MCMCCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MCMCCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMCMCIntervalPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMCMCIntervalPlot(void *p = 0);
   static void *newArray_RooStatscLcLMCMCIntervalPlot(Long_t size, void *p);
   static void delete_RooStatscLcLMCMCIntervalPlot(void *p);
   static void deleteArray_RooStatscLcLMCMCIntervalPlot(void *p);
   static void destruct_RooStatscLcLMCMCIntervalPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MCMCIntervalPlot*)
   {
      ::RooStats::MCMCIntervalPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MCMCIntervalPlot >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MCMCIntervalPlot", ::RooStats::MCMCIntervalPlot::Class_Version(), "include/RooStats/MCMCIntervalPlot.h", 42,
                  typeid(::RooStats::MCMCIntervalPlot), DefineBehavior(ptr, ptr),
                  &::RooStats::MCMCIntervalPlot::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MCMCIntervalPlot) );
      instance.SetNew(&new_RooStatscLcLMCMCIntervalPlot);
      instance.SetNewArray(&newArray_RooStatscLcLMCMCIntervalPlot);
      instance.SetDelete(&delete_RooStatscLcLMCMCIntervalPlot);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMCMCIntervalPlot);
      instance.SetDestructor(&destruct_RooStatscLcLMCMCIntervalPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MCMCIntervalPlot*)
   {
      return GenerateInitInstanceLocal((::RooStats::MCMCIntervalPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MCMCIntervalPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMetropolisHastings_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMetropolisHastings(void *p = 0);
   static void *newArray_RooStatscLcLMetropolisHastings(Long_t size, void *p);
   static void delete_RooStatscLcLMetropolisHastings(void *p);
   static void deleteArray_RooStatscLcLMetropolisHastings(void *p);
   static void destruct_RooStatscLcLMetropolisHastings(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MetropolisHastings*)
   {
      ::RooStats::MetropolisHastings *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MetropolisHastings >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MetropolisHastings", ::RooStats::MetropolisHastings::Class_Version(), "include/RooStats/MetropolisHastings.h", 36,
                  typeid(::RooStats::MetropolisHastings), DefineBehavior(ptr, ptr),
                  &::RooStats::MetropolisHastings::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MetropolisHastings) );
      instance.SetNew(&new_RooStatscLcLMetropolisHastings);
      instance.SetNewArray(&newArray_RooStatscLcLMetropolisHastings);
      instance.SetDelete(&delete_RooStatscLcLMetropolisHastings);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMetropolisHastings);
      instance.SetDestructor(&destruct_RooStatscLcLMetropolisHastings);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MetropolisHastings*)
   {
      return GenerateInitInstanceLocal((::RooStats::MetropolisHastings*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MetropolisHastings*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLProfileLikelihoodTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLProfileLikelihoodTestStat(void *p = 0);
   static void *newArray_RooStatscLcLProfileLikelihoodTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLProfileLikelihoodTestStat(void *p);
   static void deleteArray_RooStatscLcLProfileLikelihoodTestStat(void *p);
   static void destruct_RooStatscLcLProfileLikelihoodTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ProfileLikelihoodTestStat*)
   {
      ::RooStats::ProfileLikelihoodTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ProfileLikelihoodTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ProfileLikelihoodTestStat", ::RooStats::ProfileLikelihoodTestStat::Class_Version(), "include/RooStats/ProfileLikelihoodTestStat.h", 56,
                  typeid(::RooStats::ProfileLikelihoodTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::ProfileLikelihoodTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ProfileLikelihoodTestStat) );
      instance.SetNew(&new_RooStatscLcLProfileLikelihoodTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLProfileLikelihoodTestStat);
      instance.SetDelete(&delete_RooStatscLcLProfileLikelihoodTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLProfileLikelihoodTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLProfileLikelihoodTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ProfileLikelihoodTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::ProfileLikelihoodTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ProfileLikelihoodTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLMinNLLTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLMinNLLTestStat(void *p = 0);
   static void *newArray_RooStatscLcLMinNLLTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLMinNLLTestStat(void *p);
   static void deleteArray_RooStatscLcLMinNLLTestStat(void *p);
   static void destruct_RooStatscLcLMinNLLTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::MinNLLTestStat*)
   {
      ::RooStats::MinNLLTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::MinNLLTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::MinNLLTestStat", ::RooStats::MinNLLTestStat::Class_Version(), "include/RooStats/MinNLLTestStat.h", 54,
                  typeid(::RooStats::MinNLLTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::MinNLLTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::MinNLLTestStat) );
      instance.SetNew(&new_RooStatscLcLMinNLLTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLMinNLLTestStat);
      instance.SetDelete(&delete_RooStatscLcLMinNLLTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLMinNLLTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLMinNLLTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::MinNLLTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::MinNLLTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::MinNLLTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLNeymanConstruction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLNeymanConstruction(void *p);
   static void deleteArray_RooStatscLcLNeymanConstruction(void *p);
   static void destruct_RooStatscLcLNeymanConstruction(void *p);

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

namespace ROOT {
   void RooStatscLcLNumberCountingPdfFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLNumberCountingPdfFactory(void *p = 0);
   static void *newArray_RooStatscLcLNumberCountingPdfFactory(Long_t size, void *p);
   static void delete_RooStatscLcLNumberCountingPdfFactory(void *p);
   static void deleteArray_RooStatscLcLNumberCountingPdfFactory(void *p);
   static void destruct_RooStatscLcLNumberCountingPdfFactory(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::NumberCountingPdfFactory*)
   {
      ::RooStats::NumberCountingPdfFactory *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::NumberCountingPdfFactory >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::NumberCountingPdfFactory", ::RooStats::NumberCountingPdfFactory::Class_Version(), "include/RooStats/NumberCountingPdfFactory.h", 24,
                  typeid(::RooStats::NumberCountingPdfFactory), DefineBehavior(ptr, ptr),
                  &::RooStats::NumberCountingPdfFactory::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::NumberCountingPdfFactory) );
      instance.SetNew(&new_RooStatscLcLNumberCountingPdfFactory);
      instance.SetNewArray(&newArray_RooStatscLcLNumberCountingPdfFactory);
      instance.SetDelete(&delete_RooStatscLcLNumberCountingPdfFactory);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLNumberCountingPdfFactory);
      instance.SetDestructor(&destruct_RooStatscLcLNumberCountingPdfFactory);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::NumberCountingPdfFactory*)
   {
      return GenerateInitInstanceLocal((::RooStats::NumberCountingPdfFactory*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::NumberCountingPdfFactory*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace RooStats {
namespace NumberCountingUtils {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void RooStatscLcLNumberCountingUtils_Dictionary();

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

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

   }
}
}

namespace ROOT {
   void RooStatscLcLNumEventsTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLNumEventsTestStat(void *p = 0);
   static void *newArray_RooStatscLcLNumEventsTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLNumEventsTestStat(void *p);
   static void deleteArray_RooStatscLcLNumEventsTestStat(void *p);
   static void destruct_RooStatscLcLNumEventsTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::NumEventsTestStat*)
   {
      ::RooStats::NumEventsTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::NumEventsTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::NumEventsTestStat", ::RooStats::NumEventsTestStat::Class_Version(), "include/RooStats/NumEventsTestStat.h", 52,
                  typeid(::RooStats::NumEventsTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::NumEventsTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::NumEventsTestStat) );
      instance.SetNew(&new_RooStatscLcLNumEventsTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLNumEventsTestStat);
      instance.SetDelete(&delete_RooStatscLcLNumEventsTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLNumEventsTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLNumEventsTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::NumEventsTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::NumEventsTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::NumEventsTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLPdfProposal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLPdfProposal(void *p = 0);
   static void *newArray_RooStatscLcLPdfProposal(Long_t size, void *p);
   static void delete_RooStatscLcLPdfProposal(void *p);
   static void deleteArray_RooStatscLcLPdfProposal(void *p);
   static void destruct_RooStatscLcLPdfProposal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::PdfProposal*)
   {
      ::RooStats::PdfProposal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::PdfProposal >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::PdfProposal", ::RooStats::PdfProposal::Class_Version(), "include/RooStats/PdfProposal.h", 44,
                  typeid(::RooStats::PdfProposal), DefineBehavior(ptr, ptr),
                  &::RooStats::PdfProposal::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::PdfProposal) );
      instance.SetNew(&new_RooStatscLcLPdfProposal);
      instance.SetNewArray(&newArray_RooStatscLcLPdfProposal);
      instance.SetDelete(&delete_RooStatscLcLPdfProposal);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLPdfProposal);
      instance.SetDestructor(&destruct_RooStatscLcLPdfProposal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::PdfProposal*)
   {
      return GenerateInitInstanceLocal((::RooStats::PdfProposal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::PdfProposal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLProfileInspector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLProfileInspector(void *p = 0);
   static void *newArray_RooStatscLcLProfileInspector(Long_t size, void *p);
   static void delete_RooStatscLcLProfileInspector(void *p);
   static void deleteArray_RooStatscLcLProfileInspector(void *p);
   static void destruct_RooStatscLcLProfileInspector(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ProfileInspector*)
   {
      ::RooStats::ProfileInspector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ProfileInspector >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ProfileInspector", ::RooStats::ProfileInspector::Class_Version(), "include/RooStats/ProfileInspector.h", 26,
                  typeid(::RooStats::ProfileInspector), DefineBehavior(ptr, ptr),
                  &::RooStats::ProfileInspector::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ProfileInspector) );
      instance.SetNew(&new_RooStatscLcLProfileInspector);
      instance.SetNewArray(&newArray_RooStatscLcLProfileInspector);
      instance.SetDelete(&delete_RooStatscLcLProfileInspector);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLProfileInspector);
      instance.SetDestructor(&destruct_RooStatscLcLProfileInspector);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ProfileInspector*)
   {
      return GenerateInitInstanceLocal((::RooStats::ProfileInspector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ProfileInspector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLProfileLikelihoodCalculator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLProfileLikelihoodCalculator(void *p = 0);
   static void *newArray_RooStatscLcLProfileLikelihoodCalculator(Long_t size, void *p);
   static void delete_RooStatscLcLProfileLikelihoodCalculator(void *p);
   static void deleteArray_RooStatscLcLProfileLikelihoodCalculator(void *p);
   static void destruct_RooStatscLcLProfileLikelihoodCalculator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ProfileLikelihoodCalculator*)
   {
      ::RooStats::ProfileLikelihoodCalculator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ProfileLikelihoodCalculator >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ProfileLikelihoodCalculator", ::RooStats::ProfileLikelihoodCalculator::Class_Version(), "include/RooStats/ProfileLikelihoodCalculator.h", 24,
                  typeid(::RooStats::ProfileLikelihoodCalculator), DefineBehavior(ptr, ptr),
                  &::RooStats::ProfileLikelihoodCalculator::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ProfileLikelihoodCalculator) );
      instance.SetNew(&new_RooStatscLcLProfileLikelihoodCalculator);
      instance.SetNewArray(&newArray_RooStatscLcLProfileLikelihoodCalculator);
      instance.SetDelete(&delete_RooStatscLcLProfileLikelihoodCalculator);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLProfileLikelihoodCalculator);
      instance.SetDestructor(&destruct_RooStatscLcLProfileLikelihoodCalculator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ProfileLikelihoodCalculator*)
   {
      return GenerateInitInstanceLocal((::RooStats::ProfileLikelihoodCalculator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ProfileLikelihoodCalculator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLUniformProposal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLUniformProposal(void *p = 0);
   static void *newArray_RooStatscLcLUniformProposal(Long_t size, void *p);
   static void delete_RooStatscLcLUniformProposal(void *p);
   static void deleteArray_RooStatscLcLUniformProposal(void *p);
   static void destruct_RooStatscLcLUniformProposal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::UniformProposal*)
   {
      ::RooStats::UniformProposal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::UniformProposal >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::UniformProposal", ::RooStats::UniformProposal::Class_Version(), "include/RooStats/UniformProposal.h", 38,
                  typeid(::RooStats::UniformProposal), DefineBehavior(ptr, ptr),
                  &::RooStats::UniformProposal::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::UniformProposal) );
      instance.SetNew(&new_RooStatscLcLUniformProposal);
      instance.SetNewArray(&newArray_RooStatscLcLUniformProposal);
      instance.SetDelete(&delete_RooStatscLcLUniformProposal);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLUniformProposal);
      instance.SetDestructor(&destruct_RooStatscLcLUniformProposal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::UniformProposal*)
   {
      return GenerateInitInstanceLocal((::RooStats::UniformProposal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::UniformProposal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLProposalHelper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLProposalHelper(void *p = 0);
   static void *newArray_RooStatscLcLProposalHelper(Long_t size, void *p);
   static void delete_RooStatscLcLProposalHelper(void *p);
   static void deleteArray_RooStatscLcLProposalHelper(void *p);
   static void destruct_RooStatscLcLProposalHelper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ProposalHelper*)
   {
      ::RooStats::ProposalHelper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ProposalHelper >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ProposalHelper", ::RooStats::ProposalHelper::Class_Version(), "include/RooStats/ProposalHelper.h", 44,
                  typeid(::RooStats::ProposalHelper), DefineBehavior(ptr, ptr),
                  &::RooStats::ProposalHelper::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ProposalHelper) );
      instance.SetNew(&new_RooStatscLcLProposalHelper);
      instance.SetNewArray(&newArray_RooStatscLcLProposalHelper);
      instance.SetDelete(&delete_RooStatscLcLProposalHelper);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLProposalHelper);
      instance.SetDestructor(&destruct_RooStatscLcLProposalHelper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ProposalHelper*)
   {
      return GenerateInitInstanceLocal((::RooStats::ProposalHelper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ProposalHelper*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLRatioOfProfiledLikelihoodsTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p = 0);
   static void *newArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p);
   static void deleteArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p);
   static void destruct_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::RatioOfProfiledLikelihoodsTestStat*)
   {
      ::RooStats::RatioOfProfiledLikelihoodsTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::RatioOfProfiledLikelihoodsTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::RatioOfProfiledLikelihoodsTestStat", ::RooStats::RatioOfProfiledLikelihoodsTestStat::Class_Version(), "include/RooStats/RatioOfProfiledLikelihoodsTestStat.h", 42,
                  typeid(::RooStats::RatioOfProfiledLikelihoodsTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::RatioOfProfiledLikelihoodsTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::RatioOfProfiledLikelihoodsTestStat) );
      instance.SetNew(&new_RooStatscLcLRatioOfProfiledLikelihoodsTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat);
      instance.SetDelete(&delete_RooStatscLcLRatioOfProfiledLikelihoodsTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLRatioOfProfiledLikelihoodsTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::RatioOfProfiledLikelihoodsTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::RatioOfProfiledLikelihoodsTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::RatioOfProfiledLikelihoodsTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLSequentialProposal_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSequentialProposal(void *p = 0);
   static void *newArray_RooStatscLcLSequentialProposal(Long_t size, void *p);
   static void delete_RooStatscLcLSequentialProposal(void *p);
   static void deleteArray_RooStatscLcLSequentialProposal(void *p);
   static void destruct_RooStatscLcLSequentialProposal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SequentialProposal*)
   {
      ::RooStats::SequentialProposal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SequentialProposal >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SequentialProposal", ::RooStats::SequentialProposal::Class_Version(), "include/RooStats/SequentialProposal.h", 27,
                  typeid(::RooStats::SequentialProposal), DefineBehavior(ptr, ptr),
                  &::RooStats::SequentialProposal::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SequentialProposal) );
      instance.SetNew(&new_RooStatscLcLSequentialProposal);
      instance.SetNewArray(&newArray_RooStatscLcLSequentialProposal);
      instance.SetDelete(&delete_RooStatscLcLSequentialProposal);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSequentialProposal);
      instance.SetDestructor(&destruct_RooStatscLcLSequentialProposal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SequentialProposal*)
   {
      return GenerateInitInstanceLocal((::RooStats::SequentialProposal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SequentialProposal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLSimpleLikelihoodRatioTestStat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p = 0);
   static void *newArray_RooStatscLcLSimpleLikelihoodRatioTestStat(Long_t size, void *p);
   static void delete_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p);
   static void deleteArray_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p);
   static void destruct_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SimpleLikelihoodRatioTestStat*)
   {
      ::RooStats::SimpleLikelihoodRatioTestStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SimpleLikelihoodRatioTestStat >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SimpleLikelihoodRatioTestStat", ::RooStats::SimpleLikelihoodRatioTestStat::Class_Version(), "include/RooStats/SimpleLikelihoodRatioTestStat.h", 44,
                  typeid(::RooStats::SimpleLikelihoodRatioTestStat), DefineBehavior(ptr, ptr),
                  &::RooStats::SimpleLikelihoodRatioTestStat::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SimpleLikelihoodRatioTestStat) );
      instance.SetNew(&new_RooStatscLcLSimpleLikelihoodRatioTestStat);
      instance.SetNewArray(&newArray_RooStatscLcLSimpleLikelihoodRatioTestStat);
      instance.SetDelete(&delete_RooStatscLcLSimpleLikelihoodRatioTestStat);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSimpleLikelihoodRatioTestStat);
      instance.SetDestructor(&destruct_RooStatscLcLSimpleLikelihoodRatioTestStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SimpleLikelihoodRatioTestStat*)
   {
      return GenerateInitInstanceLocal((::RooStats::SimpleLikelihoodRatioTestStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SimpleLikelihoodRatioTestStat*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLSPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLSPlot(void *p = 0);
   static void *newArray_RooStatscLcLSPlot(Long_t size, void *p);
   static void delete_RooStatscLcLSPlot(void *p);
   static void deleteArray_RooStatscLcLSPlot(void *p);
   static void destruct_RooStatscLcLSPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::SPlot*)
   {
      ::RooStats::SPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::SPlot >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::SPlot", ::RooStats::SPlot::Class_Version(), "include/RooStats/SPlot.h", 34,
                  typeid(::RooStats::SPlot), DefineBehavior(ptr, ptr),
                  &::RooStats::SPlot::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::SPlot) );
      instance.SetNew(&new_RooStatscLcLSPlot);
      instance.SetNewArray(&newArray_RooStatscLcLSPlot);
      instance.SetDelete(&delete_RooStatscLcLSPlot);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLSPlot);
      instance.SetDestructor(&destruct_RooStatscLcLSPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::SPlot*)
   {
      return GenerateInitInstanceLocal((::RooStats::SPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::SPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLToyMCImportanceSampler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLToyMCImportanceSampler(void *p = 0);
   static void *newArray_RooStatscLcLToyMCImportanceSampler(Long_t size, void *p);
   static void delete_RooStatscLcLToyMCImportanceSampler(void *p);
   static void deleteArray_RooStatscLcLToyMCImportanceSampler(void *p);
   static void destruct_RooStatscLcLToyMCImportanceSampler(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ToyMCImportanceSampler*)
   {
      ::RooStats::ToyMCImportanceSampler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ToyMCImportanceSampler >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ToyMCImportanceSampler", ::RooStats::ToyMCImportanceSampler::Class_Version(), "include/RooStats/ToyMCImportanceSampler.h", 38,
                  typeid(::RooStats::ToyMCImportanceSampler), DefineBehavior(ptr, ptr),
                  &::RooStats::ToyMCImportanceSampler::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ToyMCImportanceSampler) );
      instance.SetNew(&new_RooStatscLcLToyMCImportanceSampler);
      instance.SetNewArray(&newArray_RooStatscLcLToyMCImportanceSampler);
      instance.SetDelete(&delete_RooStatscLcLToyMCImportanceSampler);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLToyMCImportanceSampler);
      instance.SetDestructor(&destruct_RooStatscLcLToyMCImportanceSampler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ToyMCImportanceSampler*)
   {
      return GenerateInitInstanceLocal((::RooStats::ToyMCImportanceSampler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ToyMCImportanceSampler*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLToyMCStudy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLToyMCStudy(void *p = 0);
   static void *newArray_RooStatscLcLToyMCStudy(Long_t size, void *p);
   static void delete_RooStatscLcLToyMCStudy(void *p);
   static void deleteArray_RooStatscLcLToyMCStudy(void *p);
   static void destruct_RooStatscLcLToyMCStudy(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ToyMCStudy*)
   {
      ::RooStats::ToyMCStudy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ToyMCStudy >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ToyMCStudy", ::RooStats::ToyMCStudy::Class_Version(), "include/RooStats/ToyMCStudy.h", 46,
                  typeid(::RooStats::ToyMCStudy), DefineBehavior(ptr, ptr),
                  &::RooStats::ToyMCStudy::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ToyMCStudy) );
      instance.SetNew(&new_RooStatscLcLToyMCStudy);
      instance.SetNewArray(&newArray_RooStatscLcLToyMCStudy);
      instance.SetDelete(&delete_RooStatscLcLToyMCStudy);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLToyMCStudy);
      instance.SetDestructor(&destruct_RooStatscLcLToyMCStudy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ToyMCStudy*)
   {
      return GenerateInitInstanceLocal((::RooStats::ToyMCStudy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ToyMCStudy*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLToyMCPayload_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_RooStatscLcLToyMCPayload(void *p = 0);
   static void *newArray_RooStatscLcLToyMCPayload(Long_t size, void *p);
   static void delete_RooStatscLcLToyMCPayload(void *p);
   static void deleteArray_RooStatscLcLToyMCPayload(void *p);
   static void destruct_RooStatscLcLToyMCPayload(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RooStats::ToyMCPayload*)
   {
      ::RooStats::ToyMCPayload *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RooStats::ToyMCPayload >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RooStats::ToyMCPayload", ::RooStats::ToyMCPayload::Class_Version(), "include/RooStats/ToyMCStudy.h", 84,
                  typeid(::RooStats::ToyMCPayload), DefineBehavior(ptr, ptr),
                  &::RooStats::ToyMCPayload::Dictionary, isa_proxy, 4,
                  sizeof(::RooStats::ToyMCPayload) );
      instance.SetNew(&new_RooStatscLcLToyMCPayload);
      instance.SetNewArray(&newArray_RooStatscLcLToyMCPayload);
      instance.SetDelete(&delete_RooStatscLcLToyMCPayload);
      instance.SetDeleteArray(&deleteArray_RooStatscLcLToyMCPayload);
      instance.SetDestructor(&destruct_RooStatscLcLToyMCPayload);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RooStats::ToyMCPayload*)
   {
      return GenerateInitInstanceLocal((::RooStats::ToyMCPayload*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::RooStats::ToyMCPayload*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void RooStatscLcLUpperLimitMCSModule_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_RooStatscLcLUpperLimitMCSModule(void *p);
   static void deleteArray_RooStatscLcLUpperLimitMCSModule(void *p);
   static void destruct_RooStatscLcLUpperLimitMCSModule(void *p);

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

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

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ModelConfig::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *TestStatistic::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SamplingDistribution::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *TestStatSampler::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestCalculatorGeneric::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *AsymptoticCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ConfInterval::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *IntervalCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SimpleInterval::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *BayesianCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *BernsteinCorrection::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *CombinedCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SamplingSummaryLookup::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *AcceptanceRegion::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SamplingSummary::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ConfidenceBelt::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *DebuggingSampler::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProofConfig::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *DetailedOutputAggregator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ToyMCSampler::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *DebuggingTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *PointSetInterval::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *FeldmanCousins::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *FrequentistCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *Heaviside::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HLFactory::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HybridCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HybridPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HybridResult::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HybridCalculatorOriginal::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestInverterResult::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestInverter::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestInverterOriginal::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SamplingDistPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestInverterPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *HypoTestPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *LikelihoodInterval::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *LikelihoodIntervalPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MarkovChain::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MaxLikelihoodEstimateTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProposalFunction::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MCMCInterval::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MCMCCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MCMCIntervalPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MetropolisHastings::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProfileLikelihoodTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *MinNLLTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *NeymanConstruction::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *NumberCountingPdfFactory::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *NumEventsTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *PdfProposal::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProfileInspector::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProfileLikelihoodCalculator::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *UniformProposal::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ProposalHelper::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *RatioOfProfiledLikelihoodsTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SequentialProposal::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SimpleLikelihoodRatioTestStat::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *SPlot::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ToyMCImportanceSampler::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ToyMCStudy::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *ToyMCPayload::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

} // namespace RooStats
      namespace RooStats {
//______________________________________________________________________________
TClass *UpperLimitMCSModule::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SPlot.
      TClass *R__cl = ::RooStats::SPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSWeightVars", &fSWeightVars);
      R__insp.InspectMember(fSWeightVars, "fSWeightVars.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSData", &fSData);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSPlot(void *p) {
      return  p ? new(p) ::RooStats::SPlot : new ::RooStats::SPlot;
   }
   static void *newArray_RooStatscLcLSPlot(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SPlot[nElements] : new ::RooStats::SPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSPlot(void *p) {
      delete ((::RooStats::SPlot*)p);
   }
   static void deleteArray_RooStatscLcLSPlot(void *p) {
      delete [] ((::RooStats::SPlot*)p);
   }
   static void destruct_RooStatscLcLSPlot(void *p) {
      typedef ::RooStats::SPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void NumberCountingPdfFactory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::NumberCountingPdfFactory.
      TClass *R__cl = ::RooStats::NumberCountingPdfFactory::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLNumberCountingPdfFactory(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::NumberCountingPdfFactory : new ::RooStats::NumberCountingPdfFactory;
   }
   static void *newArray_RooStatscLcLNumberCountingPdfFactory(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::NumberCountingPdfFactory[nElements] : new ::RooStats::NumberCountingPdfFactory[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLNumberCountingPdfFactory(void *p) {
      delete ((::RooStats::NumberCountingPdfFactory*)p);
   }
   static void deleteArray_RooStatscLcLNumberCountingPdfFactory(void *p) {
      delete [] ((::RooStats::NumberCountingPdfFactory*)p);
   }
   static void destruct_RooStatscLcLNumberCountingPdfFactory(void *p) {
      typedef ::RooStats::NumberCountingPdfFactory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::NumberCountingPdfFactory

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestResult.
      TClass *R__cl = ::RooStats::HypoTestResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullPValue", &fNullPValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlternatePValue", &fAlternatePValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullPValueError", &fNullPValueError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlternatePValueError", &fAlternatePValueError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStatisticData", &fTestStatisticData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllTestStatisticsData", &fAllTestStatisticsData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNullDistr", &fNullDistr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltDistr", &fAltDistr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNullDetailedOutput", &fNullDetailedOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltDetailedOutput", &fAltDetailedOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitInfo", &fFitInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPValueIsRightTail", &fPValueIsRightTail);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackgroundIsAlt", &fBackgroundIsAlt);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHypoTestResult(void *p) {
      return  p ? new(p) ::RooStats::HypoTestResult : new ::RooStats::HypoTestResult;
   }
   static void *newArray_RooStatscLcLHypoTestResult(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HypoTestResult[nElements] : new ::RooStats::HypoTestResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestResult(void *p) {
      delete ((::RooStats::HypoTestResult*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestResult(void *p) {
      delete [] ((::RooStats::HypoTestResult*)p);
   }
   static void destruct_RooStatscLcLHypoTestResult(void *p) {
      typedef ::RooStats::HypoTestResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestResult

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestPlot.
      TClass *R__cl = ::RooStats::HypoTestPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHypoTestResult", &fHypoTestResult);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::SamplingDistPlot baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHypoTestPlot(void *p) {
      return  p ? new(p) ::RooStats::HypoTestPlot : new ::RooStats::HypoTestPlot;
   }
   static void *newArray_RooStatscLcLHypoTestPlot(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HypoTestPlot[nElements] : new ::RooStats::HypoTestPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestPlot(void *p) {
      delete ((::RooStats::HypoTestPlot*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestPlot(void *p) {
      delete [] ((::RooStats::HypoTestPlot*)p);
   }
   static void destruct_RooStatscLcLHypoTestPlot(void *p) {
      typedef ::RooStats::HypoTestPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ConfInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ConfInterval.
      TClass *R__cl = ::RooStats::ConfInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLConfInterval(void *p) {
      delete ((::RooStats::ConfInterval*)p);
   }
   static void deleteArray_RooStatscLcLConfInterval(void *p) {
      delete [] ((::RooStats::ConfInterval*)p);
   }
   static void destruct_RooStatscLcLConfInterval(void *p) {
      typedef ::RooStats::ConfInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ConfInterval

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SimpleInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SimpleInterval.
      TClass *R__cl = ::RooStats::SimpleInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", &fParameters);
      R__insp.InspectMember(fParameters, "fParameters.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerLimit", &fLowerLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimit", &fUpperLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfidenceLevel", &fConfidenceLevel);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ConfInterval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSimpleInterval(void *p) {
      return  p ? new(p) ::RooStats::SimpleInterval : new ::RooStats::SimpleInterval;
   }
   static void *newArray_RooStatscLcLSimpleInterval(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SimpleInterval[nElements] : new ::RooStats::SimpleInterval[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSimpleInterval(void *p) {
      delete ((::RooStats::SimpleInterval*)p);
   }
   static void deleteArray_RooStatscLcLSimpleInterval(void *p) {
      delete [] ((::RooStats::SimpleInterval*)p);
   }
   static void destruct_RooStatscLcLSimpleInterval(void *p) {
      typedef ::RooStats::SimpleInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SimpleInterval

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void LikelihoodInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::LikelihoodInterval.
      TClass *R__cl = ::RooStats::LikelihoodInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", &fParameters);
      R__insp.InspectMember(fParameters, "fParameters.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBestFitParams", &fBestFitParams);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLikelihoodRatio", &fLikelihoodRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfidenceLevel", &fConfidenceLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerLimits", (void*)&fLowerLimits);
      R__insp.InspectMember("map<std::string,double>", (void*)&fLowerLimits, "fLowerLimits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimits", (void*)&fUpperLimits);
      R__insp.InspectMember("map<std::string,double>", (void*)&fUpperLimits, "fUpperLimits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizer", (void*)&fMinimizer);
      R__insp.InspectMember("auto_ptr<ROOT::Math::Minimizer>", (void*)&fMinimizer, "fMinimizer.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFunctor", (void*)&fFunctor);
      R__insp.InspectMember("auto_ptr<RooFunctor>", (void*)&fFunctor, "fFunctor.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinFunc", (void*)&fMinFunc);
      R__insp.InspectMember("auto_ptr<ROOT::Math::IMultiGenFunction>", (void*)&fMinFunc, "fMinFunc.", true);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ConfInterval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLLikelihoodInterval(void *p) {
      return  p ? new(p) ::RooStats::LikelihoodInterval : new ::RooStats::LikelihoodInterval;
   }
   static void *newArray_RooStatscLcLLikelihoodInterval(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::LikelihoodInterval[nElements] : new ::RooStats::LikelihoodInterval[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLLikelihoodInterval(void *p) {
      delete ((::RooStats::LikelihoodInterval*)p);
   }
   static void deleteArray_RooStatscLcLLikelihoodInterval(void *p) {
      delete [] ((::RooStats::LikelihoodInterval*)p);
   }
   static void destruct_RooStatscLcLLikelihoodInterval(void *p) {
      typedef ::RooStats::LikelihoodInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::LikelihoodInterval

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void PointSetInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::PointSetInterval.
      TClass *R__cl = ::RooStats::PointSetInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfidenceLevel", &fConfidenceLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParameterPointsInInterval", &fParameterPointsInInterval);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ConfInterval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLPointSetInterval(void *p) {
      return  p ? new(p) ::RooStats::PointSetInterval : new ::RooStats::PointSetInterval;
   }
   static void *newArray_RooStatscLcLPointSetInterval(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::PointSetInterval[nElements] : new ::RooStats::PointSetInterval[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLPointSetInterval(void *p) {
      delete ((::RooStats::PointSetInterval*)p);
   }
   static void deleteArray_RooStatscLcLPointSetInterval(void *p) {
      delete [] ((::RooStats::PointSetInterval*)p);
   }
   static void destruct_RooStatscLcLPointSetInterval(void *p) {
      typedef ::RooStats::PointSetInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::PointSetInterval

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ModelConfig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ModelConfig.
      TClass *R__cl = ::RooStats::ModelConfig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefWS", &fRefWS);
      R__insp.InspectMember(fRefWS, "fRefWS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWSName", (void*)&fWSName);
      R__insp.InspectMember("string", (void*)&fWSName, "fWSName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdfName", (void*)&fPdfName);
      R__insp.InspectMember("string", (void*)&fPdfName, "fPdfName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataName", (void*)&fDataName);
      R__insp.InspectMember("string", (void*)&fDataName, "fDataName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPOIName", (void*)&fPOIName);
      R__insp.InspectMember("string", (void*)&fPOIName, "fPOIName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNuisParamsName", (void*)&fNuisParamsName);
      R__insp.InspectMember("string", (void*)&fNuisParamsName, "fNuisParamsName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstrParamsName", (void*)&fConstrParamsName);
      R__insp.InspectMember("string", (void*)&fConstrParamsName, "fConstrParamsName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriorPdfName", (void*)&fPriorPdfName);
      R__insp.InspectMember("string", (void*)&fPriorPdfName, "fPriorPdfName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObsName", (void*)&fConditionalObsName);
      R__insp.InspectMember("string", (void*)&fConditionalObsName, "fConditionalObsName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobalObsName", (void*)&fGlobalObsName);
      R__insp.InspectMember("string", (void*)&fGlobalObsName, "fGlobalObsName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtoDataName", (void*)&fProtoDataName);
      R__insp.InspectMember("string", (void*)&fProtoDataName, "fProtoDataName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSnapshotName", (void*)&fSnapshotName);
      R__insp.InspectMember("string", (void*)&fSnapshotName, "fSnapshotName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fObservablesName", (void*)&fObservablesName);
      R__insp.InspectMember("string", (void*)&fObservablesName, "fObservablesName.", false);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLModelConfig(void *p) {
      return  p ? new(p) ::RooStats::ModelConfig : new ::RooStats::ModelConfig;
   }
   static void *newArray_RooStatscLcLModelConfig(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::ModelConfig[nElements] : new ::RooStats::ModelConfig[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLModelConfig(void *p) {
      delete ((::RooStats::ModelConfig*)p);
   }
   static void deleteArray_RooStatscLcLModelConfig(void *p) {
      delete [] ((::RooStats::ModelConfig*)p);
   }
   static void destruct_RooStatscLcLModelConfig(void *p) {
      typedef ::RooStats::ModelConfig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ModelConfig

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void IntervalCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::IntervalCalculator.
      TClass *R__cl = ::RooStats::IntervalCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLIntervalCalculator(void *p) {
      delete ((::RooStats::IntervalCalculator*)p);
   }
   static void deleteArray_RooStatscLcLIntervalCalculator(void *p) {
      delete [] ((::RooStats::IntervalCalculator*)p);
   }
   static void destruct_RooStatscLcLIntervalCalculator(void *p) {
      typedef ::RooStats::IntervalCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::IntervalCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestCalculator.
      TClass *R__cl = ::RooStats::HypoTestCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestCalculator(void *p) {
      delete ((::RooStats::HypoTestCalculator*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestCalculator(void *p) {
      delete [] ((::RooStats::HypoTestCalculator*)p);
   }
   static void destruct_RooStatscLcLHypoTestCalculator(void *p) {
      typedef ::RooStats::HypoTestCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void CombinedCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::CombinedCalculator.
      TClass *R__cl = ::RooStats::CombinedCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPOI", &fPOI);
      R__insp.InspectMember(fPOI, "fPOI.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullParams", &fNullParams);
      R__insp.InspectMember(fNullParams, "fNullParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlternateParams", &fAlternateParams);
      R__insp.InspectMember(fAlternateParams, "fAlternateParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNuisParams", &fNuisParams);
      R__insp.InspectMember(fNuisParams, "fNuisParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculator baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLCombinedCalculator(void *p) {
      delete ((::RooStats::CombinedCalculator*)p);
   }
   static void deleteArray_RooStatscLcLCombinedCalculator(void *p) {
      delete [] ((::RooStats::CombinedCalculator*)p);
   }
   static void destruct_RooStatscLcLCombinedCalculator(void *p) {
      typedef ::RooStats::CombinedCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::CombinedCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProfileLikelihoodCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProfileLikelihoodCalculator.
      TClass *R__cl = ::RooStats::ProfileLikelihoodCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitResult", &fFitResult);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::CombinedCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLProfileLikelihoodCalculator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileLikelihoodCalculator : new ::RooStats::ProfileLikelihoodCalculator;
   }
   static void *newArray_RooStatscLcLProfileLikelihoodCalculator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileLikelihoodCalculator[nElements] : new ::RooStats::ProfileLikelihoodCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLProfileLikelihoodCalculator(void *p) {
      delete ((::RooStats::ProfileLikelihoodCalculator*)p);
   }
   static void deleteArray_RooStatscLcLProfileLikelihoodCalculator(void *p) {
      delete [] ((::RooStats::ProfileLikelihoodCalculator*)p);
   }
   static void destruct_RooStatscLcLProfileLikelihoodCalculator(void *p) {
      typedef ::RooStats::ProfileLikelihoodCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProfileLikelihoodCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MCMCCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MCMCCalculator.
      TClass *R__cl = ::RooStats::MCMCCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPOI", &fPOI);
      R__insp.InspectMember(fPOI, "fPOI.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNuisParams", &fNuisParams);
      R__insp.InspectMember(fNuisParams, "fNuisParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChainParams", &fChainParams);
      R__insp.InspectMember(fChainParams, "fChainParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPropFunc", &fPropFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorPdf", &fPriorPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumIters", &fNumIters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumBurnInSteps", &fNumBurnInSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumBins", &fNumBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxes", &fAxes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseKeys", &fUseKeys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSparseHist", &fUseSparseHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftSideTF", &fLeftSideTF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &fEpsilon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntervalType", &fIntervalType);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMCMCCalculator(void *p) {
      return  p ? new(p) ::RooStats::MCMCCalculator : new ::RooStats::MCMCCalculator;
   }
   static void *newArray_RooStatscLcLMCMCCalculator(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::MCMCCalculator[nElements] : new ::RooStats::MCMCCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMCMCCalculator(void *p) {
      delete ((::RooStats::MCMCCalculator*)p);
   }
   static void deleteArray_RooStatscLcLMCMCCalculator(void *p) {
      delete [] ((::RooStats::MCMCCalculator*)p);
   }
   static void destruct_RooStatscLcLMCMCCalculator(void *p) {
      typedef ::RooStats::MCMCCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MCMCCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MCMCInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MCMCInterval.
      TClass *R__cl = ::RooStats::MCMCInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", &fParameters);
      R__insp.InspectMember(fParameters, "fParameters.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChain", &fChain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfidenceLevel", &fConfidenceLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataHist", &fDataHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSparseHist", &fSparseHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistConfLevel", &fHistConfLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistCutoff", &fHistCutoff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeysPdf", &fKeysPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProduct", &fProduct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaviside", &fHeaviside);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeysDataHist", &fKeysDataHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCutoffVar", &fCutoffVar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeysConfLevel", &fKeysConfLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeysCutoff", &fKeysCutoff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFull", &fFull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftSideTF", &fLeftSideTF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFConfLevel", &fTFConfLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVector", (void*)&fVector);
      R__insp.InspectMember("vector<Int_t>", (void*)&fVector, "fVector.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVecWeight", &fVecWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFLower", &fTFLower);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTFUpper", &fTFUpper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseKeys", &fUseKeys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSparseHist", &fUseSparseHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsHistStrict", &fIsHistStrict);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDimension", &fDimension);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumBurnInSteps", &fNumBurnInSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxes", &fAxes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &fEpsilon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntervalType", &fIntervalType);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ConfInterval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMCMCInterval(void *p) {
      return  p ? new(p) ::RooStats::MCMCInterval : new ::RooStats::MCMCInterval;
   }
   static void *newArray_RooStatscLcLMCMCInterval(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::MCMCInterval[nElements] : new ::RooStats::MCMCInterval[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMCMCInterval(void *p) {
      delete ((::RooStats::MCMCInterval*)p);
   }
   static void deleteArray_RooStatscLcLMCMCInterval(void *p) {
      delete [] ((::RooStats::MCMCInterval*)p);
   }
   static void destruct_RooStatscLcLMCMCInterval(void *p) {
      typedef ::RooStats::MCMCInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MCMCInterval

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MCMCIntervalPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MCMCIntervalPlot.
      TClass *R__cl = ::RooStats::MCMCIntervalPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterval", &fInterval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParameters", &fParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorHist", &fPosteriorHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorKeysPdf", &fPosteriorKeysPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorKeysProduct", &fPosteriorKeysProduct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNLLHist", &fNLLHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWeightHist", &fWeightHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorHistHistCopy", &fPosteriorHistHistCopy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorHistTFCopy", &fPosteriorHistTFCopy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDimension", &fDimension);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineColor", &fLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShadeColor", &fShadeColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineWidth", &fLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowBurnIn", &fShowBurnIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWalk", &fWalk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBurnIn", &fBurnIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParamGraph", &fParamGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNLLGraph", &fNLLGraph);
      TNamed::ShowMembers(R__insp);
      RooPrintable::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMCMCIntervalPlot(void *p) {
      return  p ? new(p) ::RooStats::MCMCIntervalPlot : new ::RooStats::MCMCIntervalPlot;
   }
   static void *newArray_RooStatscLcLMCMCIntervalPlot(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::MCMCIntervalPlot[nElements] : new ::RooStats::MCMCIntervalPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMCMCIntervalPlot(void *p) {
      delete ((::RooStats::MCMCIntervalPlot*)p);
   }
   static void deleteArray_RooStatscLcLMCMCIntervalPlot(void *p) {
      delete [] ((::RooStats::MCMCIntervalPlot*)p);
   }
   static void destruct_RooStatscLcLMCMCIntervalPlot(void *p) {
      typedef ::RooStats::MCMCIntervalPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MCMCIntervalPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MetropolisHastings::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MetropolisHastings.
      TClass *R__cl = ::RooStats::MetropolisHastings::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &fFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", &fParameters);
      R__insp.InspectMember(fParameters, "fParameters.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChainParams", &fChainParams);
      R__insp.InspectMember(fChainParams, "fChainParams.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPropFunc", &fPropFunc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumIters", &fNumIters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumBurnInSteps", &fNumBurnInSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSign", &fSign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMetropolisHastings(void *p) {
      return  p ? new(p) ::RooStats::MetropolisHastings : new ::RooStats::MetropolisHastings;
   }
   static void *newArray_RooStatscLcLMetropolisHastings(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::MetropolisHastings[nElements] : new ::RooStats::MetropolisHastings[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMetropolisHastings(void *p) {
      delete ((::RooStats::MetropolisHastings*)p);
   }
   static void deleteArray_RooStatscLcLMetropolisHastings(void *p) {
      delete [] ((::RooStats::MetropolisHastings*)p);
   }
   static void destruct_RooStatscLcLMetropolisHastings(void *p) {
      typedef ::RooStats::MetropolisHastings current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MetropolisHastings

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MarkovChain::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MarkovChain.
      TClass *R__cl = ::RooStats::MarkovChain::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParameters", &fParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataEntry", &fDataEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChain", &fChain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNLL", &fNLL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWeight", &fWeight);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMarkovChain(void *p) {
      return  p ? new(p) ::RooStats::MarkovChain : new ::RooStats::MarkovChain;
   }
   static void *newArray_RooStatscLcLMarkovChain(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::MarkovChain[nElements] : new ::RooStats::MarkovChain[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMarkovChain(void *p) {
      delete ((::RooStats::MarkovChain*)p);
   }
   static void deleteArray_RooStatscLcLMarkovChain(void *p) {
      delete [] ((::RooStats::MarkovChain*)p);
   }
   static void destruct_RooStatscLcLMarkovChain(void *p) {
      typedef ::RooStats::MarkovChain current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MarkovChain

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProposalFunction::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProposalFunction.
      TClass *R__cl = ::RooStats::ProposalFunction::IsA();
      if (R__cl || R__insp.IsA()) { }
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLProposalFunction(void *p) {
      delete ((::RooStats::ProposalFunction*)p);
   }
   static void deleteArray_RooStatscLcLProposalFunction(void *p) {
      delete [] ((::RooStats::ProposalFunction*)p);
   }
   static void destruct_RooStatscLcLProposalFunction(void *p) {
      typedef ::RooStats::ProposalFunction current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProposalFunction

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProposalHelper::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProposalHelper.
      TClass *R__cl = ::RooStats::ProposalHelper::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCluesPdf", &fCluesPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUniformPdf", &fUniformPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClues", &fClues);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCovMatrix", &fCovMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdfProp", &fPdfProp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVars", &fVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheSize", &fCacheSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigmaRangeDivisor", &fSigmaRangeDivisor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUniFrac", &fUniFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCluesFrac", &fCluesFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsPdfProp", &fOwnsPdfProp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsPdf", &fOwnsPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsCluesPdf", &fOwnsCluesPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsVars", &fOwnsVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseUpdates", &fUseUpdates);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCluesOptions", &fCluesOptions);
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLProposalHelper(void *p) {
      return  p ? new(p) ::RooStats::ProposalHelper : new ::RooStats::ProposalHelper;
   }
   static void *newArray_RooStatscLcLProposalHelper(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::ProposalHelper[nElements] : new ::RooStats::ProposalHelper[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLProposalHelper(void *p) {
      delete ((::RooStats::ProposalHelper*)p);
   }
   static void deleteArray_RooStatscLcLProposalHelper(void *p) {
      delete [] ((::RooStats::ProposalHelper*)p);
   }
   static void destruct_RooStatscLcLProposalHelper(void *p) {
      typedef ::RooStats::ProposalHelper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProposalHelper

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

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

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

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLUniformProposal(void *p) {
      return  p ? new(p) ::RooStats::UniformProposal : new ::RooStats::UniformProposal;
   }
   static void *newArray_RooStatscLcLUniformProposal(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::UniformProposal[nElements] : new ::RooStats::UniformProposal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLUniformProposal(void *p) {
      delete ((::RooStats::UniformProposal*)p);
   }
   static void deleteArray_RooStatscLcLUniformProposal(void *p) {
      delete [] ((::RooStats::UniformProposal*)p);
   }
   static void destruct_RooStatscLcLUniformProposal(void *p) {
      typedef ::RooStats::UniformProposal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::UniformProposal

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void PdfProposal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::PdfProposal.
      TClass *R__cl = ::RooStats::PdfProposal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMap", (void*)&fMap);
      R__insp.InspectMember("map<RooRealVar*,RooAbsReal*>", (void*)&fMap, "fMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIt", (void*)&fIt);
      R__insp.InspectMember("map<RooRealVar*,RooAbsReal*,less<RooRealVar*>,allocator<pair<RooRealVar* const,RooAbsReal*> > >::iterator", (void*)&fIt, "fIt.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastX", &fLastX);
      R__insp.InspectMember(fLastX, "fLastX.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheSize", &fCacheSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCachePosition", &fCachePosition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCache", &fCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaster", &fMaster);
      R__insp.InspectMember(fMaster, "fMaster.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnsPdf", &fOwnsPdf);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ProposalFunction baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLPdfProposal(void *p) {
      return  p ? new(p) ::RooStats::PdfProposal : new ::RooStats::PdfProposal;
   }
   static void *newArray_RooStatscLcLPdfProposal(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::PdfProposal[nElements] : new ::RooStats::PdfProposal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLPdfProposal(void *p) {
      delete ((::RooStats::PdfProposal*)p);
   }
   static void deleteArray_RooStatscLcLPdfProposal(void *p) {
      delete [] ((::RooStats::PdfProposal*)p);
   }
   static void destruct_RooStatscLcLPdfProposal(void *p) {
      typedef ::RooStats::PdfProposal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::PdfProposal

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void Heaviside::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::Heaviside.
      TClass *R__cl = ::RooStats::Heaviside::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "x", &x);
      R__insp.InspectMember(x, "x.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "c", &c);
      R__insp.InspectMember(c, "c.");
      RooAbsReal::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHeaviside(void *p) {
      return  p ? new(p) ::RooStats::Heaviside : new ::RooStats::Heaviside;
   }
   static void *newArray_RooStatscLcLHeaviside(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::Heaviside[nElements] : new ::RooStats::Heaviside[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHeaviside(void *p) {
      delete ((::RooStats::Heaviside*)p);
   }
   static void deleteArray_RooStatscLcLHeaviside(void *p) {
      delete [] ((::RooStats::Heaviside*)p);
   }
   static void destruct_RooStatscLcLHeaviside(void *p) {
      typedef ::RooStats::Heaviside current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::Heaviside

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SequentialProposal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SequentialProposal.
      TClass *R__cl = ::RooStats::SequentialProposal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDivisor", &fDivisor);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ProposalFunction baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSequentialProposal(void *p) {
      return  p ? new(p) ::RooStats::SequentialProposal : new ::RooStats::SequentialProposal;
   }
   static void *newArray_RooStatscLcLSequentialProposal(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SequentialProposal[nElements] : new ::RooStats::SequentialProposal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSequentialProposal(void *p) {
      delete ((::RooStats::SequentialProposal*)p);
   }
   static void deleteArray_RooStatscLcLSequentialProposal(void *p) {
      delete [] ((::RooStats::SequentialProposal*)p);
   }
   static void destruct_RooStatscLcLSequentialProposal(void *p) {
      typedef ::RooStats::SequentialProposal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SequentialProposal

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestCalculatorGeneric::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestCalculatorGeneric.
      TClass *R__cl = ::RooStats::HypoTestCalculatorGeneric::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltModel", &fAltModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNullModel", &fNullModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTestStatSampler", &fTestStatSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultSampler", &fDefaultSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultTestStat", &fDefaultTestStat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAltToysSeed", &fAltToysSeed);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestCalculatorGeneric(void *p) {
      delete ((::RooStats::HypoTestCalculatorGeneric*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestCalculatorGeneric(void *p) {
      delete [] ((::RooStats::HypoTestCalculatorGeneric*)p);
   }
   static void destruct_RooStatscLcLHypoTestCalculatorGeneric(void *p) {
      typedef ::RooStats::HypoTestCalculatorGeneric current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestCalculatorGeneric

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HybridCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HybridCalculator.
      TClass *R__cl = ::RooStats::HybridCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorNuisanceNull", &fPriorNuisanceNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorNuisanceAlt", &fPriorNuisanceAlt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriorNuisanceNullExternal", &fPriorNuisanceNullExternal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriorNuisanceAltExternal", &fPriorNuisanceAltExternal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysNull", &fNToysNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysAlt", &fNToysAlt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysNullTail", &fNToysNullTail);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysAltTail", &fNToysAltTail);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculatorGeneric baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLHybridCalculator(void *p) {
      delete ((::RooStats::HybridCalculator*)p);
   }
   static void deleteArray_RooStatscLcLHybridCalculator(void *p) {
      delete [] ((::RooStats::HybridCalculator*)p);
   }
   static void destruct_RooStatscLcLHybridCalculator(void *p) {
      typedef ::RooStats::HybridCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HybridCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void FrequentistCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::FrequentistCalculator.
      TClass *R__cl = ::RooStats::FrequentistCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConditionalMLEsNull", &fConditionalMLEsNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConditionalMLEsAlt", &fConditionalMLEsAlt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysNull", &fNToysNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysAlt", &fNToysAlt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysNullTail", &fNToysNullTail);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToysAltTail", &fNToysAltTail);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitInfo", &fFitInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStoreFitInfo", &fStoreFitInfo);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculatorGeneric baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLFrequentistCalculator(void *p) {
      delete ((::RooStats::FrequentistCalculator*)p);
   }
   static void deleteArray_RooStatscLcLFrequentistCalculator(void *p) {
      delete [] ((::RooStats::FrequentistCalculator*)p);
   }
   static void destruct_RooStatscLcLFrequentistCalculator(void *p) {
      typedef ::RooStats::FrequentistCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::FrequentistCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void AsymptoticCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::AsymptoticCalculator.
      TClass *R__cl = ::RooStats::AsymptoticCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOneSided", &fOneSided);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOneSidedDiscovery", &fOneSidedDiscovery);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseQTilde", &fUseQTilde);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNLLObs", &fNLLObs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNLLAsimov", &fNLLAsimov);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAsimovData", &fAsimovData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsimovGlobObs", &fAsimovGlobObs);
      R__insp.InspectMember(fAsimovGlobObs, "fAsimovGlobObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBestFitPoi", &fBestFitPoi);
      R__insp.InspectMember(fBestFitPoi, "fBestFitPoi.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBestFitParams", &fBestFitParams);
      R__insp.InspectMember(fBestFitParams, "fBestFitParams.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculatorGeneric baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLAsymptoticCalculator(void *p) {
      delete ((::RooStats::AsymptoticCalculator*)p);
   }
   static void deleteArray_RooStatscLcLAsymptoticCalculator(void *p) {
      delete [] ((::RooStats::AsymptoticCalculator*)p);
   }
   static void destruct_RooStatscLcLAsymptoticCalculator(void *p) {
      typedef ::RooStats::AsymptoticCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::AsymptoticCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HybridCalculatorOriginal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HybridCalculatorOriginal.
      TClass *R__cl = ::RooStats::HybridCalculatorOriginal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStatisticsIdx", &fTestStatisticsIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToys", &fNToys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSbModel", &fSbModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBModel", &fBModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObservables", &fObservables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNuisanceParameters", &fNuisanceParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorPdf", &fPriorPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenerateBinned", &fGenerateBinned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUsePriorPdf", &fUsePriorPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmpDoExtended", &fTmpDoExtended);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHybridCalculatorOriginal(void *p) {
      return  p ? new(p) ::RooStats::HybridCalculatorOriginal : new ::RooStats::HybridCalculatorOriginal;
   }
   static void *newArray_RooStatscLcLHybridCalculatorOriginal(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HybridCalculatorOriginal[nElements] : new ::RooStats::HybridCalculatorOriginal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHybridCalculatorOriginal(void *p) {
      delete ((::RooStats::HybridCalculatorOriginal*)p);
   }
   static void deleteArray_RooStatscLcLHybridCalculatorOriginal(void *p) {
      delete [] ((::RooStats::HybridCalculatorOriginal*)p);
   }
   static void destruct_RooStatscLcLHybridCalculatorOriginal(void *p) {
      typedef ::RooStats::HybridCalculatorOriginal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HybridCalculatorOriginal

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HybridPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HybridPlot.
      TClass *R__cl = ::RooStats::HybridPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSb_histo", &fSb_histo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSb_histo_shaded", &fSb_histo_shaded);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fB_histo", &fB_histo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fB_histo_shaded", &fB_histo_shaded);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData_testStat_line", &fData_testStat_line);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegend", &fLegend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLHybridPlot(void *p) {
      delete ((::RooStats::HybridPlot*)p);
   }
   static void deleteArray_RooStatscLcLHybridPlot(void *p) {
      delete [] ((::RooStats::HybridPlot*)p);
   }
   static void destruct_RooStatscLcLHybridPlot(void *p) {
      typedef ::RooStats::HybridPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HybridPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HybridResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HybridResult.
      TClass *R__cl = ::RooStats::HybridResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStat_b", (void*)&fTestStat_b);
      R__insp.InspectMember("vector<double>", (void*)&fTestStat_b, "fTestStat_b.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStat_sb", (void*)&fTestStat_sb);
      R__insp.InspectMember("vector<double>", (void*)&fTestStat_sb, "fTestStat_sb.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStat_data", &fTestStat_data);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fComputationsNulDoneFlag", &fComputationsNulDoneFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fComputationsAltDoneFlag", &fComputationsAltDoneFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumLargerValues", &fSumLargerValues);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::HypoTestResult baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHybridResult(void *p) {
      return  p ? new(p) ::RooStats::HybridResult : new ::RooStats::HybridResult;
   }
   static void *newArray_RooStatscLcLHybridResult(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HybridResult[nElements] : new ::RooStats::HybridResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHybridResult(void *p) {
      delete ((::RooStats::HybridResult*)p);
   }
   static void deleteArray_RooStatscLcLHybridResult(void *p) {
      delete [] ((::RooStats::HybridResult*)p);
   }
   static void destruct_RooStatscLcLHybridResult(void *p) {
      typedef ::RooStats::HybridResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HybridResult

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void DetailedOutputAggregator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::DetailedOutputAggregator.
      TClass *R__cl = ::RooStats::DetailedOutputAggregator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResult", &fResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuiltSet", &fBuiltSet);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLDetailedOutputAggregator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::DetailedOutputAggregator : new ::RooStats::DetailedOutputAggregator;
   }
   static void *newArray_RooStatscLcLDetailedOutputAggregator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::DetailedOutputAggregator[nElements] : new ::RooStats::DetailedOutputAggregator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLDetailedOutputAggregator(void *p) {
      delete ((::RooStats::DetailedOutputAggregator*)p);
   }
   static void deleteArray_RooStatscLcLDetailedOutputAggregator(void *p) {
      delete [] ((::RooStats::DetailedOutputAggregator*)p);
   }
   static void destruct_RooStatscLcLDetailedOutputAggregator(void *p) {
      typedef ::RooStats::DetailedOutputAggregator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::DetailedOutputAggregator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void TestStatSampler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::TestStatSampler.
      TClass *R__cl = ::RooStats::TestStatSampler::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLTestStatSampler(void *p) {
      delete ((::RooStats::TestStatSampler*)p);
   }
   static void deleteArray_RooStatscLcLTestStatSampler(void *p) {
      delete [] ((::RooStats::TestStatSampler*)p);
   }
   static void destruct_RooStatscLcLTestStatSampler(void *p) {
      typedef ::RooStats::TestStatSampler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::TestStatSampler

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void DebuggingSampler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::DebuggingSampler.
      TClass *R__cl = ::RooStats::DebuggingSampler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTestStatistic", &fTestStatistic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRand", &fRand);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatSampler baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLDebuggingSampler(void *p) {
      delete ((::RooStats::DebuggingSampler*)p);
   }
   static void deleteArray_RooStatscLcLDebuggingSampler(void *p) {
      delete [] ((::RooStats::DebuggingSampler*)p);
   }
   static void destruct_RooStatscLcLDebuggingSampler(void *p) {
      typedef ::RooStats::DebuggingSampler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::DebuggingSampler

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ToyMCSampler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ToyMCSampler.
      TClass *R__cl = ::RooStats::ToyMCSampler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParametersForTestStat", &fParametersForTestStat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestStatistics", (void*)&fTestStatistics);
      R__insp.InspectMember("vector<TestStatistic*>", (void*)&fTestStatistics, "fTestStatistics.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingDistName", (void*)&fSamplingDistName);
      R__insp.InspectMember("string", (void*)&fSamplingDistName, "fSamplingDistName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorNuisance", &fPriorNuisance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNuisancePars", &fNuisancePars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObservables", &fObservables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalObservables", &fGlobalObservables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNToys", &fNToys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEvents", &fNEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExpectedNuisancePar", &fExpectedNuisancePar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenerateBinned", &fGenerateBinned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenerateBinnedTag", &fGenerateBinnedTag);
      R__insp.InspectMember(fGenerateBinnedTag, "fGenerateBinnedTag.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenerateAutoBinned", &fGenerateAutoBinned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToysInTails", &fToysInTails);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxToys", &fMaxToys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveLowLimit", &fAdaptiveLowLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveHighLimit", &fAdaptiveHighLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProtoData", &fProtoData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProofConfig", &fProofConfig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNuisanceParametersSampler", &fNuisanceParametersSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_allVars", &_allVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "_pdfList", (void*)&_pdfList);
      R__insp.InspectMember("list<RooAbsPdf*>", (void*)&_pdfList, "_pdfList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "_obsList", (void*)&_obsList);
      R__insp.InspectMember("list<RooArgSet*>", (void*)&_obsList, "_obsList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "_gsList", (void*)&_gsList);
      R__insp.InspectMember("list<RooAbsPdf::GenSpec*>", (void*)&_gsList, "_gsList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_gs1", &_gs1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_gs2", &_gs2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_gs3", &_gs3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_gs4", &_gs4);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMultiGen", &fUseMultiGen);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatSampler baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLToyMCSampler(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ToyMCSampler : new ::RooStats::ToyMCSampler;
   }
   static void *newArray_RooStatscLcLToyMCSampler(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ToyMCSampler[nElements] : new ::RooStats::ToyMCSampler[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLToyMCSampler(void *p) {
      delete ((::RooStats::ToyMCSampler*)p);
   }
   static void deleteArray_RooStatscLcLToyMCSampler(void *p) {
      delete [] ((::RooStats::ToyMCSampler*)p);
   }
   static void destruct_RooStatscLcLToyMCSampler(void *p) {
      typedef ::RooStats::ToyMCSampler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ToyMCSampler

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ToyMCStudy::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ToyMCStudy.
      TClass *R__cl = ::RooStats::ToyMCStudy::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToyMCSampler", &fToyMCSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParamPoint", &fParamPoint);
      R__insp.InspectMember(fParamPoint, "fParamPoint.");
      RooAbsStudy::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLToyMCStudy(void *p) {
      return  p ? new(p) ::RooStats::ToyMCStudy : new ::RooStats::ToyMCStudy;
   }
   static void *newArray_RooStatscLcLToyMCStudy(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::ToyMCStudy[nElements] : new ::RooStats::ToyMCStudy[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLToyMCStudy(void *p) {
      delete ((::RooStats::ToyMCStudy*)p);
   }
   static void deleteArray_RooStatscLcLToyMCStudy(void *p) {
      delete [] ((::RooStats::ToyMCStudy*)p);
   }
   static void destruct_RooStatscLcLToyMCStudy(void *p) {
      typedef ::RooStats::ToyMCStudy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ToyMCStudy

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProofConfig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProofConfig.
      TClass *R__cl = ::RooStats::ProofConfig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNExperiments", &fNExperiments);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHost", &fHost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowGui", &fShowGui);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLProofConfig(void *p) {
      delete ((::RooStats::ProofConfig*)p);
   }
   static void deleteArray_RooStatscLcLProofConfig(void *p) {
      delete [] ((::RooStats::ProofConfig*)p);
   }
   static void destruct_RooStatscLcLProofConfig(void *p) {
      typedef ::RooStats::ProofConfig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProofConfig

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ToyMCImportanceSampler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ToyMCImportanceSampler.
      TClass *R__cl = ::RooStats::ToyMCImportanceSampler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndexGenDensity", &fIndexGenDensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenerateFromNull", &fGenerateFromNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fApplyVeto", &fApplyVeto);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullDensities", (void*)&fNullDensities);
      R__insp.InspectMember("vector<RooAbsPdf*>", (void*)&fNullDensities, "fNullDensities.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullSnapshots", (void*)&fNullSnapshots);
      R__insp.InspectMember("vector<const RooArgSet*>", (void*)&fNullSnapshots, "fNullSnapshots.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImportanceDensities", (void*)&fImportanceDensities);
      R__insp.InspectMember("vector<RooAbsPdf*>", (void*)&fImportanceDensities, "fImportanceDensities.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImportanceSnapshots", (void*)&fImportanceSnapshots);
      R__insp.InspectMember("vector<const RooArgSet*>", (void*)&fImportanceSnapshots, "fImportanceSnapshots.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReuseNLL", &fReuseNLL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToysStrategy", &fToysStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullNLLs", (void*)&fNullNLLs);
      R__insp.InspectMember("vector<RooAbsReal*>", (void*)&fNullNLLs, "fNullNLLs.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImpNLLs", (void*)&fImpNLLs);
      R__insp.InspectMember("vector<RooAbsReal*>", (void*)&fImpNLLs, "fImpNLLs.", true);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::ToyMCSampler baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLToyMCImportanceSampler(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ToyMCImportanceSampler : new ::RooStats::ToyMCImportanceSampler;
   }
   static void *newArray_RooStatscLcLToyMCImportanceSampler(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ToyMCImportanceSampler[nElements] : new ::RooStats::ToyMCImportanceSampler[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLToyMCImportanceSampler(void *p) {
      delete ((::RooStats::ToyMCImportanceSampler*)p);
   }
   static void deleteArray_RooStatscLcLToyMCImportanceSampler(void *p) {
      delete [] ((::RooStats::ToyMCImportanceSampler*)p);
   }
   static void destruct_RooStatscLcLToyMCImportanceSampler(void *p) {
      typedef ::RooStats::ToyMCImportanceSampler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ToyMCImportanceSampler

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ToyMCPayload::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ToyMCPayload.
      TClass *R__cl = ::RooStats::ToyMCPayload::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSet", &fDataSet);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLToyMCPayload(void *p) {
      return  p ? new(p) ::RooStats::ToyMCPayload : new ::RooStats::ToyMCPayload;
   }
   static void *newArray_RooStatscLcLToyMCPayload(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::ToyMCPayload[nElements] : new ::RooStats::ToyMCPayload[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLToyMCPayload(void *p) {
      delete ((::RooStats::ToyMCPayload*)p);
   }
   static void deleteArray_RooStatscLcLToyMCPayload(void *p) {
      delete [] ((::RooStats::ToyMCPayload*)p);
   }
   static void destruct_RooStatscLcLToyMCPayload(void *p) {
      typedef ::RooStats::ToyMCPayload current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ToyMCPayload

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void TestStatistic::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::TestStatistic.
      TClass *R__cl = ::RooStats::TestStatistic::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLTestStatistic(void *p) {
      delete ((::RooStats::TestStatistic*)p);
   }
   static void deleteArray_RooStatscLcLTestStatistic(void *p) {
      delete [] ((::RooStats::TestStatistic*)p);
   }
   static void destruct_RooStatscLcLTestStatistic(void *p) {
      typedef ::RooStats::TestStatistic current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::TestStatistic

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void DebuggingTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::DebuggingTestStat.
      TClass *R__cl = ::RooStats::DebuggingTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTestStatistic", &fTestStatistic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRand", &fRand);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLDebuggingTestStat(void *p) {
      delete ((::RooStats::DebuggingTestStat*)p);
   }
   static void deleteArray_RooStatscLcLDebuggingTestStat(void *p) {
      delete [] ((::RooStats::DebuggingTestStat*)p);
   }
   static void destruct_RooStatscLcLDebuggingTestStat(void *p) {
      typedef ::RooStats::DebuggingTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::DebuggingTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProfileLikelihoodTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProfileLikelihoodTestStat.
      TClass *R__cl = ::RooStats::ProfileLikelihoodTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNll", &fNll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCachedBestFitParams", &fCachedBestFitParams);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastData", &fLastData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimitType", &fLimitType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigned", &fSigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetailedOutputEnabled", &fDetailedOutputEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetailedOutputWithErrorsAndPulls", &fDetailedOutputWithErrorsAndPulls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDetailedOutput", &fDetailedOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarName", &fVarName);
      R__insp.InspectMember(fVarName, "fVarName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReuseNll", &fReuseNll);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizer", &fMinimizer);
      R__insp.InspectMember(fMinimizer, "fMinimizer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrategy", &fStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTolerance", &fTolerance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintLevel", &fPrintLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLOffset", &fLOffset);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLProfileLikelihoodTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileLikelihoodTestStat : new ::RooStats::ProfileLikelihoodTestStat;
   }
   static void *newArray_RooStatscLcLProfileLikelihoodTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileLikelihoodTestStat[nElements] : new ::RooStats::ProfileLikelihoodTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLProfileLikelihoodTestStat(void *p) {
      delete ((::RooStats::ProfileLikelihoodTestStat*)p);
   }
   static void deleteArray_RooStatscLcLProfileLikelihoodTestStat(void *p) {
      delete [] ((::RooStats::ProfileLikelihoodTestStat*)p);
   }
   static void destruct_RooStatscLcLProfileLikelihoodTestStat(void *p) {
      typedef ::RooStats::ProfileLikelihoodTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProfileLikelihoodTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void RatioOfProfiledLikelihoodsTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::RatioOfProfiledLikelihoodsTestStat.
      TClass *R__cl = ::RooStats::RatioOfProfiledLikelihoodsTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNullProfile", &fNullProfile);
      R__insp.InspectMember(fNullProfile, "fNullProfile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAltProfile", &fAltProfile);
      R__insp.InspectMember(fAltProfile, "fAltProfile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltPOI", &fAltPOI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubtractMLE", &fSubtractMLE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetailedOutputEnabled", &fDetailedOutputEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDetailedOutput", &fDetailedOutput);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::RatioOfProfiledLikelihoodsTestStat : new ::RooStats::RatioOfProfiledLikelihoodsTestStat;
   }
   static void *newArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::RatioOfProfiledLikelihoodsTestStat[nElements] : new ::RooStats::RatioOfProfiledLikelihoodsTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p) {
      delete ((::RooStats::RatioOfProfiledLikelihoodsTestStat*)p);
   }
   static void deleteArray_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p) {
      delete [] ((::RooStats::RatioOfProfiledLikelihoodsTestStat*)p);
   }
   static void destruct_RooStatscLcLRatioOfProfiledLikelihoodsTestStat(void *p) {
      typedef ::RooStats::RatioOfProfiledLikelihoodsTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::RatioOfProfiledLikelihoodsTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void NumEventsTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::NumEventsTestStat.
      TClass *R__cl = ::RooStats::NumEventsTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLNumEventsTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::NumEventsTestStat : new ::RooStats::NumEventsTestStat;
   }
   static void *newArray_RooStatscLcLNumEventsTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::NumEventsTestStat[nElements] : new ::RooStats::NumEventsTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLNumEventsTestStat(void *p) {
      delete ((::RooStats::NumEventsTestStat*)p);
   }
   static void deleteArray_RooStatscLcLNumEventsTestStat(void *p) {
      delete [] ((::RooStats::NumEventsTestStat*)p);
   }
   static void destruct_RooStatscLcLNumEventsTestStat(void *p) {
      typedef ::RooStats::NumEventsTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::NumEventsTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SimpleLikelihoodRatioTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SimpleLikelihoodRatioTestStat.
      TClass *R__cl = ::RooStats::SimpleLikelihoodRatioTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNullPdf", &fNullPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltPdf", &fAltPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNullParameters", &fNullParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAltParameters", &fAltParameters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstEval", &fFirstEval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetailedOutputEnabled", &fDetailedOutputEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDetailedOutput", &fDetailedOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNllNull", &fNllNull);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNllAlt", &fNllAlt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReuseNll", &fReuseNll);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::SimpleLikelihoodRatioTestStat : new ::RooStats::SimpleLikelihoodRatioTestStat;
   }
   static void *newArray_RooStatscLcLSimpleLikelihoodRatioTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::SimpleLikelihoodRatioTestStat[nElements] : new ::RooStats::SimpleLikelihoodRatioTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p) {
      delete ((::RooStats::SimpleLikelihoodRatioTestStat*)p);
   }
   static void deleteArray_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p) {
      delete [] ((::RooStats::SimpleLikelihoodRatioTestStat*)p);
   }
   static void destruct_RooStatscLcLSimpleLikelihoodRatioTestStat(void *p) {
      typedef ::RooStats::SimpleLikelihoodRatioTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SimpleLikelihoodRatioTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MaxLikelihoodEstimateTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MaxLikelihoodEstimateTestStat.
      TClass *R__cl = ::RooStats::MaxLikelihoodEstimateTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParameter", &fParameter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimit", &fUpperLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizer", &fMinimizer);
      R__insp.InspectMember(fMinimizer, "fMinimizer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrategy", &fStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintLevel", &fPrintLevel);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::MaxLikelihoodEstimateTestStat : new ::RooStats::MaxLikelihoodEstimateTestStat;
   }
   static void *newArray_RooStatscLcLMaxLikelihoodEstimateTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::MaxLikelihoodEstimateTestStat[nElements] : new ::RooStats::MaxLikelihoodEstimateTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p) {
      delete ((::RooStats::MaxLikelihoodEstimateTestStat*)p);
   }
   static void deleteArray_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p) {
      delete [] ((::RooStats::MaxLikelihoodEstimateTestStat*)p);
   }
   static void destruct_RooStatscLcLMaxLikelihoodEstimateTestStat(void *p) {
      typedef ::RooStats::MaxLikelihoodEstimateTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MaxLikelihoodEstimateTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void MinNLLTestStat::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::MinNLLTestStat.
      TClass *R__cl = ::RooStats::MinNLLTestStat::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProflts", &fProflts);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::TestStatistic baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLMinNLLTestStat(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::MinNLLTestStat : new ::RooStats::MinNLLTestStat;
   }
   static void *newArray_RooStatscLcLMinNLLTestStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::MinNLLTestStat[nElements] : new ::RooStats::MinNLLTestStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLMinNLLTestStat(void *p) {
      delete ((::RooStats::MinNLLTestStat*)p);
   }
   static void deleteArray_RooStatscLcLMinNLLTestStat(void *p) {
      delete [] ((::RooStats::MinNLLTestStat*)p);
   }
   static void destruct_RooStatscLcLMinNLLTestStat(void *p) {
      typedef ::RooStats::MinNLLTestStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::MinNLLTestStat

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SamplingDistribution::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SamplingDistribution.
      TClass *R__cl = ::RooStats::SamplingDistribution::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingDist", (void*)&fSamplingDist);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSamplingDist, "fSamplingDist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSampleWeights", (void*)&fSampleWeights);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSampleWeights, "fSampleWeights.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarName", &fVarName);
      R__insp.InspectMember(fVarName, "fVarName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumW", (void*)&fSumW);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSumW, "fSumW.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumW2", (void*)&fSumW2);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSumW2, "fSumW2.", true);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSamplingDistribution(void *p) {
      return  p ? new(p) ::RooStats::SamplingDistribution : new ::RooStats::SamplingDistribution;
   }
   static void *newArray_RooStatscLcLSamplingDistribution(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SamplingDistribution[nElements] : new ::RooStats::SamplingDistribution[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSamplingDistribution(void *p) {
      delete ((::RooStats::SamplingDistribution*)p);
   }
   static void deleteArray_RooStatscLcLSamplingDistribution(void *p) {
      delete [] ((::RooStats::SamplingDistribution*)p);
   }
   static void destruct_RooStatscLcLSamplingDistribution(void *p) {
      typedef ::RooStats::SamplingDistribution current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SamplingDistribution

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void NeymanConstruction::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::NeymanConstruction.
      TClass *R__cl = ::RooStats::NeymanConstruction::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTestStatSampler", &fTestStatSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointsToTest", &fPointsToTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftSideFraction", &fLeftSideFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConfBelt", &fConfBelt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveSampling", &fAdaptiveSampling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdditionalNToysFactor", &fAdditionalNToysFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBeltToFile", &fSaveBeltToFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreateBelt", &fCreateBelt);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLNeymanConstruction(void *p) {
      delete ((::RooStats::NeymanConstruction*)p);
   }
   static void deleteArray_RooStatscLcLNeymanConstruction(void *p) {
      delete [] ((::RooStats::NeymanConstruction*)p);
   }
   static void destruct_RooStatscLcLNeymanConstruction(void *p) {
      typedef ::RooStats::NeymanConstruction current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::NeymanConstruction

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void FeldmanCousins::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::FeldmanCousins.
      TClass *R__cl = ::RooStats::FeldmanCousins::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTestStatSampler", &fTestStatSampler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointsToTest", &fPointsToTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPOIToTest", &fPOIToTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConfBelt", &fConfBelt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveSampling", &fAdaptiveSampling);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdditionalNToysFactor", &fAdditionalNToysFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFluctuateData", &fFluctuateData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoProfileConstruction", &fDoProfileConstruction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBeltToFile", &fSaveBeltToFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreateBelt", &fCreateBelt);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLFeldmanCousins(void *p) {
      delete ((::RooStats::FeldmanCousins*)p);
   }
   static void deleteArray_RooStatscLcLFeldmanCousins(void *p) {
      delete [] ((::RooStats::FeldmanCousins*)p);
   }
   static void destruct_RooStatscLcLFeldmanCousins(void *p) {
      typedef ::RooStats::FeldmanCousins current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::FeldmanCousins

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void BayesianCalculator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::BayesianCalculator.
      TClass *R__cl = ::RooStats::BayesianCalculator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdf", &fPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPOI", &fPOI);
      R__insp.InspectMember(fPOI, "fPOI.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPriorPdf", &fPriorPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNuisancePdf", &fNuisancePdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNuisanceParameters", &fNuisanceParameters);
      R__insp.InspectMember(fNuisanceParameters, "fNuisanceParameters.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConditionalObs", &fConditionalObs);
      R__insp.InspectMember(fConditionalObs, "fConditionalObs.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProductPdf", &fProductPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogLike", &fLogLike);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLikelihood", &fLikelihood);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegratedLikelihood", &fIntegratedLikelihood);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorPdf", &fPosteriorPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPosteriorFunction", &fPosteriorFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApproxPosterior", &fApproxPosterior);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLower", &fLower);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpper", &fUpper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNLLMin", &fNLLMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeftSideFraction", &fLeftSideFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBrfPrecision", &fBrfPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNScanBins", &fNScanBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumIterations", &fNumIterations);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidInterval", &fValidInterval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegrationType", &fIntegrationType);
      R__insp.InspectMember(fIntegrationType, "fIntegrationType.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLBayesianCalculator(void *p) {
      return  p ? new(p) ::RooStats::BayesianCalculator : new ::RooStats::BayesianCalculator;
   }
   static void *newArray_RooStatscLcLBayesianCalculator(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::BayesianCalculator[nElements] : new ::RooStats::BayesianCalculator[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLBayesianCalculator(void *p) {
      delete ((::RooStats::BayesianCalculator*)p);
   }
   static void deleteArray_RooStatscLcLBayesianCalculator(void *p) {
      delete [] ((::RooStats::BayesianCalculator*)p);
   }
   static void destruct_RooStatscLcLBayesianCalculator(void *p) {
      typedef ::RooStats::BayesianCalculator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::BayesianCalculator

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestInverter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestInverter.
      TClass *R__cl = ::RooStats::HypoTestInverter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimitPlot", (void*)&fLimitPlot);
      R__insp.InspectMember("auto_ptr<TGraphErrors>", (void*)&fLimitPlot, "fLimitPlot.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalToysRun", &fTotalToysRun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxToys", &fMaxToys);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalculator0", &fCalculator0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHC", (void*)&fHC);
      R__insp.InspectMember("auto_ptr<RooStats::HypoTestCalculatorGeneric>", (void*)&fHC, "fHC.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScannedVariable", &fScannedVariable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResults", &fResults);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseCLs", &fUseCLs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScanLog", &fScanLog);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalcType", &fCalcType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBins", &fNBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumErr", &fNumErr);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHypoTestInverter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::HypoTestInverter : new ::RooStats::HypoTestInverter;
   }
   static void *newArray_RooStatscLcLHypoTestInverter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::HypoTestInverter[nElements] : new ::RooStats::HypoTestInverter[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestInverter(void *p) {
      delete ((::RooStats::HypoTestInverter*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestInverter(void *p) {
      delete [] ((::RooStats::HypoTestInverter*)p);
   }
   static void destruct_RooStatscLcLHypoTestInverter(void *p) {
      typedef ::RooStats::HypoTestInverter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestInverter

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestInverterOriginal::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestInverterOriginal.
      TClass *R__cl = ::RooStats::HypoTestInverterOriginal::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalculator0", &fCalculator0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScannedVariable", &fScannedVariable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResults", &fResults);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseCLs", &fUseCLs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::IntervalCalculator baseClass1;
      baseClass1::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHypoTestInverterOriginal(void *p) {
      return  p ? new(p) ::RooStats::HypoTestInverterOriginal : new ::RooStats::HypoTestInverterOriginal;
   }
   static void *newArray_RooStatscLcLHypoTestInverterOriginal(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HypoTestInverterOriginal[nElements] : new ::RooStats::HypoTestInverterOriginal[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestInverterOriginal(void *p) {
      delete ((::RooStats::HypoTestInverterOriginal*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestInverterOriginal(void *p) {
      delete [] ((::RooStats::HypoTestInverterOriginal*)p);
   }
   static void destruct_RooStatscLcLHypoTestInverterOriginal(void *p) {
      typedef ::RooStats::HypoTestInverterOriginal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestInverterOriginal

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestInverterResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestInverterResult.
      TClass *R__cl = ::RooStats::HypoTestInverterResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseCLs", &fUseCLs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTwoSided", &fIsTwoSided);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolateLowerLimit", &fInterpolateLowerLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolateUpperLimit", &fInterpolateUpperLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFittedLowerLimit", &fFittedLowerLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFittedUpperLimit", &fFittedUpperLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolOption", &fInterpolOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerLimitError", &fLowerLimitError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimitError", &fUpperLimitError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCLsCleanupThreshold", &fCLsCleanupThreshold);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXValues", (void*)&fXValues);
      R__insp.InspectMember("vector<double>", (void*)&fXValues, "fXValues.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYObjects", &fYObjects);
      R__insp.InspectMember(fYObjects, "fYObjects.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExpPValues", &fExpPValues);
      R__insp.InspectMember(fExpPValues, "fExpPValues.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef RooStats::SimpleInterval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHypoTestInverterResult(void *p) {
      return  p ? new(p) ::RooStats::HypoTestInverterResult : new ::RooStats::HypoTestInverterResult;
   }
   static void *newArray_RooStatscLcLHypoTestInverterResult(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HypoTestInverterResult[nElements] : new ::RooStats::HypoTestInverterResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestInverterResult(void *p) {
      delete ((::RooStats::HypoTestInverterResult*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestInverterResult(void *p) {
      delete [] ((::RooStats::HypoTestInverterResult*)p);
   }
   static void destruct_RooStatscLcLHypoTestInverterResult(void *p) {
      typedef ::RooStats::HypoTestInverterResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestInverterResult

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HypoTestInverterPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HypoTestInverterPlot.
      TClass *R__cl = ::RooStats::HypoTestInverterPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResults", &fResults);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLHypoTestInverterPlot(void *p) {
      delete ((::RooStats::HypoTestInverterPlot*)p);
   }
   static void deleteArray_RooStatscLcLHypoTestInverterPlot(void *p) {
      delete [] ((::RooStats::HypoTestInverterPlot*)p);
   }
   static void destruct_RooStatscLcLHypoTestInverterPlot(void *p) {
      typedef ::RooStats::HypoTestInverterPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HypoTestInverterPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void HLFactory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::HLFactory.
      TClass *R__cl = ::RooStats::HLFactory::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboCat", &fComboCat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboBkgPdf", &fComboBkgPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboSigBkgPdf", &fComboSigBkgPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComboDataset", &fComboDataset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCombinationDone", &fCombinationDone);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigBkgPdfNames", &fSigBkgPdfNames);
      R__insp.InspectMember(fSigBkgPdfNames, "fSigBkgPdfNames.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBkgPdfNames", &fBkgPdfNames);
      R__insp.InspectMember(fBkgPdfNames, "fBkgPdfNames.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDatasetsNames", &fDatasetsNames);
      R__insp.InspectMember(fDatasetsNames, "fDatasetsNames.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelsNames", &fLabelsNames);
      R__insp.InspectMember(fLabelsNames, "fLabelsNames.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInclusionLevel", &fInclusionLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWs", &fWs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnWs", &fOwnWs);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLHLFactory(void *p) {
      return  p ? new(p) ::RooStats::HLFactory : new ::RooStats::HLFactory;
   }
   static void *newArray_RooStatscLcLHLFactory(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::HLFactory[nElements] : new ::RooStats::HLFactory[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLHLFactory(void *p) {
      delete ((::RooStats::HLFactory*)p);
   }
   static void deleteArray_RooStatscLcLHLFactory(void *p) {
      delete [] ((::RooStats::HLFactory*)p);
   }
   static void destruct_RooStatscLcLHLFactory(void *p) {
      typedef ::RooStats::HLFactory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::HLFactory

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ConfidenceBelt::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ConfidenceBelt.
      TClass *R__cl = ::RooStats::ConfidenceBelt::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingSummaryLookup", &fSamplingSummaryLookup);
      R__insp.InspectMember(fSamplingSummaryLookup, "fSamplingSummaryLookup.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingSummaries", (void*)&fSamplingSummaries);
      R__insp.InspectMember("vector<SamplingSummary>", (void*)&fSamplingSummaries, "fSamplingSummaries.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParameterPoints", &fParameterPoints);
      TNamed::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLConfidenceBelt(void *p) {
      return  p ? new(p) ::RooStats::ConfidenceBelt : new ::RooStats::ConfidenceBelt;
   }
   static void *newArray_RooStatscLcLConfidenceBelt(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::ConfidenceBelt[nElements] : new ::RooStats::ConfidenceBelt[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLConfidenceBelt(void *p) {
      delete ((::RooStats::ConfidenceBelt*)p);
   }
   static void deleteArray_RooStatscLcLConfidenceBelt(void *p) {
      delete [] ((::RooStats::ConfidenceBelt*)p);
   }
   static void destruct_RooStatscLcLConfidenceBelt(void *p) {
      typedef ::RooStats::ConfidenceBelt current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ConfidenceBelt

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void AcceptanceRegion::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::AcceptanceRegion.
      TClass *R__cl = ::RooStats::AcceptanceRegion::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLookupIndex", &fLookupIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerLimit", &fLowerLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimit", &fUpperLimit);
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLAcceptanceRegion(void *p) {
      return  p ? new(p) ::RooStats::AcceptanceRegion : new ::RooStats::AcceptanceRegion;
   }
   static void *newArray_RooStatscLcLAcceptanceRegion(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::AcceptanceRegion[nElements] : new ::RooStats::AcceptanceRegion[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLAcceptanceRegion(void *p) {
      delete ((::RooStats::AcceptanceRegion*)p);
   }
   static void deleteArray_RooStatscLcLAcceptanceRegion(void *p) {
      delete [] ((::RooStats::AcceptanceRegion*)p);
   }
   static void destruct_RooStatscLcLAcceptanceRegion(void *p) {
      typedef ::RooStats::AcceptanceRegion current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::AcceptanceRegion

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SamplingSummary::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SamplingSummary.
      TClass *R__cl = ::RooStats::SamplingSummary::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameterPointIndex", &fParameterPointIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingDistribution", &fSamplingDistribution);
      R__insp.InspectMember(fSamplingDistribution, "fSamplingDistribution.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAcceptanceRegions", (void*)&fAcceptanceRegions);
      R__insp.InspectMember("map<Int_t,AcceptanceRegion>", (void*)&fAcceptanceRegions, "fAcceptanceRegions.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSamplingSummary(void *p) {
      return  p ? new(p) ::RooStats::SamplingSummary : new ::RooStats::SamplingSummary;
   }
   static void *newArray_RooStatscLcLSamplingSummary(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SamplingSummary[nElements] : new ::RooStats::SamplingSummary[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSamplingSummary(void *p) {
      delete ((::RooStats::SamplingSummary*)p);
   }
   static void deleteArray_RooStatscLcLSamplingSummary(void *p) {
      delete [] ((::RooStats::SamplingSummary*)p);
   }
   static void destruct_RooStatscLcLSamplingSummary(void *p) {
      typedef ::RooStats::SamplingSummary current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SamplingSummary

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SamplingSummaryLookup::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SamplingSummaryLookup.
      TClass *R__cl = ::RooStats::SamplingSummaryLookup::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLookupTable", (void*)&fLookupTable);
      R__insp.InspectMember("RooStats::SamplingSummaryLookup::LookupTable", (void*)&fLookupTable, "fLookupTable.", false);
      TObject::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSamplingSummaryLookup(void *p) {
      return  p ? new(p) ::RooStats::SamplingSummaryLookup : new ::RooStats::SamplingSummaryLookup;
   }
   static void *newArray_RooStatscLcLSamplingSummaryLookup(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SamplingSummaryLookup[nElements] : new ::RooStats::SamplingSummaryLookup[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSamplingSummaryLookup(void *p) {
      delete ((::RooStats::SamplingSummaryLookup*)p);
   }
   static void deleteArray_RooStatscLcLSamplingSummaryLookup(void *p) {
      delete [] ((::RooStats::SamplingSummaryLookup*)p);
   }
   static void destruct_RooStatscLcLSamplingSummaryLookup(void *p) {
      typedef ::RooStats::SamplingSummaryLookup current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SamplingSummaryLookup

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void BernsteinCorrection::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::BernsteinCorrection.
      TClass *R__cl = ::RooStats::BernsteinCorrection::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxCorrection", &fMaxCorrection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTolerance", &fTolerance);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLBernsteinCorrection(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::BernsteinCorrection : new ::RooStats::BernsteinCorrection;
   }
   static void *newArray_RooStatscLcLBernsteinCorrection(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::BernsteinCorrection[nElements] : new ::RooStats::BernsteinCorrection[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLBernsteinCorrection(void *p) {
      delete ((::RooStats::BernsteinCorrection*)p);
   }
   static void deleteArray_RooStatscLcLBernsteinCorrection(void *p) {
      delete [] ((::RooStats::BernsteinCorrection*)p);
   }
   static void destruct_RooStatscLcLBernsteinCorrection(void *p) {
      typedef ::RooStats::BernsteinCorrection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::BernsteinCorrection

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void ProfileInspector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::ProfileInspector.
      TClass *R__cl = ::RooStats::ProfileInspector::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLProfileInspector(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileInspector : new ::RooStats::ProfileInspector;
   }
   static void *newArray_RooStatscLcLProfileInspector(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::RooStats::ProfileInspector[nElements] : new ::RooStats::ProfileInspector[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLProfileInspector(void *p) {
      delete ((::RooStats::ProfileInspector*)p);
   }
   static void deleteArray_RooStatscLcLProfileInspector(void *p) {
      delete [] ((::RooStats::ProfileInspector*)p);
   }
   static void destruct_RooStatscLcLProfileInspector(void *p) {
      typedef ::RooStats::ProfileInspector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::ProfileInspector

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void SamplingDistPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::SamplingDistPlot.
      TClass *R__cl = ::RooStats::SamplingDistPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingDistr", (void*)&fSamplingDistr);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSamplingDistr, "fSamplingDistr.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSampleWeights", (void*)&fSampleWeights);
      R__insp.InspectMember("vector<Double_t>", (void*)&fSampleWeights, "fSampleWeights.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsWeighted", &fIsWeighted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBins", &fBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerType", &fMarkerType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarName", &fVarName);
      R__insp.InspectMember(fVarName, "fVarName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegend", &fLegend);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fItems", &fItems);
      R__insp.InspectMember(fItems, "fItems.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOtherItems", &fOtherItems);
      R__insp.InspectMember(fOtherItems, "fOtherItems.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIterator", &fIterator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRooPlot", &fRooPlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogXaxis", &fLogXaxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogYaxis", &fLogYaxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXMin", &fXMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXMax", &fXMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYMin", &fYMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYMax", &fYMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fApplyStyle", &fApplyStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillStyle", &fFillStyle);
      TNamed::ShowMembers(R__insp);
      RooPrintable::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLSamplingDistPlot(void *p) {
      return  p ? new(p) ::RooStats::SamplingDistPlot : new ::RooStats::SamplingDistPlot;
   }
   static void *newArray_RooStatscLcLSamplingDistPlot(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::SamplingDistPlot[nElements] : new ::RooStats::SamplingDistPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLSamplingDistPlot(void *p) {
      delete ((::RooStats::SamplingDistPlot*)p);
   }
   static void deleteArray_RooStatscLcLSamplingDistPlot(void *p) {
      delete [] ((::RooStats::SamplingDistPlot*)p);
   }
   static void destruct_RooStatscLcLSamplingDistPlot(void *p) {
      typedef ::RooStats::SamplingDistPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::SamplingDistPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void LikelihoodIntervalPlot::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::LikelihoodIntervalPlot.
      TClass *R__cl = ::RooStats::LikelihoodIntervalPlot::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillStyle", &fFillStyle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineColor", &fLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdimPlot", &fNdimPlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPoints", &fNPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmin", &fYmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYmax", &fYmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrecision", &fPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterval", &fInterval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParamsPlot", &fParamsPlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlotObject", &fPlotObject);
      TNamed::ShowMembers(R__insp);
      RooPrintable::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrappers around operator new
   static void *new_RooStatscLcLLikelihoodIntervalPlot(void *p) {
      return  p ? new(p) ::RooStats::LikelihoodIntervalPlot : new ::RooStats::LikelihoodIntervalPlot;
   }
   static void *newArray_RooStatscLcLLikelihoodIntervalPlot(Long_t nElements, void *p) {
      return p ? new(p) ::RooStats::LikelihoodIntervalPlot[nElements] : new ::RooStats::LikelihoodIntervalPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_RooStatscLcLLikelihoodIntervalPlot(void *p) {
      delete ((::RooStats::LikelihoodIntervalPlot*)p);
   }
   static void deleteArray_RooStatscLcLLikelihoodIntervalPlot(void *p) {
      delete [] ((::RooStats::LikelihoodIntervalPlot*)p);
   }
   static void destruct_RooStatscLcLLikelihoodIntervalPlot(void *p) {
      typedef ::RooStats::LikelihoodIntervalPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::LikelihoodIntervalPlot

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

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

} // namespace RooStats
//______________________________________________________________________________
      namespace RooStats {
void UpperLimitMCSModule::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class RooStats::UpperLimitMCSModule.
      TClass *R__cl = ::RooStats::UpperLimitMCSModule::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "_parName", (void*)&_parName);
      R__insp.InspectMember("string", (void*)&_parName, "_parName.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_plc", &_plc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_ul", &_ul);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_poi", &_poi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_data", &_data);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "_cl", &_cl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*_model", &_model);
      RooAbsMCStudyModule::ShowMembers(R__insp);
}

} // namespace RooStats
namespace ROOT {
   // Wrapper around operator delete
   static void delete_RooStatscLcLUpperLimitMCSModule(void *p) {
      delete ((::RooStats::UpperLimitMCSModule*)p);
   }
   static void deleteArray_RooStatscLcLUpperLimitMCSModule(void *p) {
      delete [] ((::RooStats::UpperLimitMCSModule*)p);
   }
   static void destruct_RooStatscLcLUpperLimitMCSModule(void *p) {
      typedef ::RooStats::UpperLimitMCSModule current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RooStats::UpperLimitMCSModule

namespace ROOT {
   void maplERooRealVarmUcORooAbsRealmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplERooRealVarmUcORooAbsRealmUgR_Dictionary();
   static void *new_maplERooRealVarmUcORooAbsRealmUgR(void *p = 0);
   static void *newArray_maplERooRealVarmUcORooAbsRealmUgR(Long_t size, void *p);
   static void delete_maplERooRealVarmUcORooAbsRealmUgR(void *p);
   static void deleteArray_maplERooRealVarmUcORooAbsRealmUgR(void *p);
   static void destruct_maplERooRealVarmUcORooAbsRealmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<RooRealVar*,RooAbsReal*>*)
   {
      map<RooRealVar*,RooAbsReal*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<RooRealVar*,RooAbsReal*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<RooRealVar*,RooAbsReal*>", -2, "prec_stl/map", 63,
                  typeid(map<RooRealVar*,RooAbsReal*>), DefineBehavior(ptr, ptr),
                  0, &maplERooRealVarmUcORooAbsRealmUgR_Dictionary, isa_proxy, 0,
                  sizeof(map<RooRealVar*,RooAbsReal*>) );
      instance.SetNew(&new_maplERooRealVarmUcORooAbsRealmUgR);
      instance.SetNewArray(&newArray_maplERooRealVarmUcORooAbsRealmUgR);
      instance.SetDelete(&delete_maplERooRealVarmUcORooAbsRealmUgR);
      instance.SetDeleteArray(&deleteArray_maplERooRealVarmUcORooAbsRealmUgR);
      instance.SetDestructor(&destruct_maplERooRealVarmUcORooAbsRealmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<RooRealVar*,RooAbsReal*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<RooRealVar*,RooAbsReal*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplERooRealVarmUcORooAbsRealmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const map<RooRealVar*,RooAbsReal*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplERooRealVarmUcORooAbsRealmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<RooRealVar*,RooAbsReal*> : new map<RooRealVar*,RooAbsReal*>;
   }
   static void *newArray_maplERooRealVarmUcORooAbsRealmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<RooRealVar*,RooAbsReal*>[nElements] : new map<RooRealVar*,RooAbsReal*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplERooRealVarmUcORooAbsRealmUgR(void *p) {
      delete ((map<RooRealVar*,RooAbsReal*>*)p);
   }
   static void deleteArray_maplERooRealVarmUcORooAbsRealmUgR(void *p) {
      delete [] ((map<RooRealVar*,RooAbsReal*>*)p);
   }
   static void destruct_maplERooRealVarmUcORooAbsRealmUgR(void *p) {
      typedef map<RooRealVar*,RooAbsReal*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<RooRealVar*,RooAbsReal*>

namespace ROOT {
   void maplEintcORooStatscLcLAcceptanceRegiongR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEintcORooStatscLcLAcceptanceRegiongR_Dictionary();
   static void *new_maplEintcORooStatscLcLAcceptanceRegiongR(void *p = 0);
   static void *newArray_maplEintcORooStatscLcLAcceptanceRegiongR(Long_t size, void *p);
   static void delete_maplEintcORooStatscLcLAcceptanceRegiongR(void *p);
   static void deleteArray_maplEintcORooStatscLcLAcceptanceRegiongR(void *p);
   static void destruct_maplEintcORooStatscLcLAcceptanceRegiongR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,RooStats::AcceptanceRegion>*)
   {
      map<int,RooStats::AcceptanceRegion> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,RooStats::AcceptanceRegion>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,RooStats::AcceptanceRegion>", -2, "prec_stl/map", 63,
                  typeid(map<int,RooStats::AcceptanceRegion>), DefineBehavior(ptr, ptr),
                  0, &maplEintcORooStatscLcLAcceptanceRegiongR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,RooStats::AcceptanceRegion>) );
      instance.SetNew(&new_maplEintcORooStatscLcLAcceptanceRegiongR);
      instance.SetNewArray(&newArray_maplEintcORooStatscLcLAcceptanceRegiongR);
      instance.SetDelete(&delete_maplEintcORooStatscLcLAcceptanceRegiongR);
      instance.SetDeleteArray(&deleteArray_maplEintcORooStatscLcLAcceptanceRegiongR);
      instance.SetDestructor(&destruct_maplEintcORooStatscLcLAcceptanceRegiongR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,RooStats::AcceptanceRegion> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,RooStats::AcceptanceRegion>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEintcORooStatscLcLAcceptanceRegiongR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const map<int,RooStats::AcceptanceRegion>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcORooStatscLcLAcceptanceRegiongR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,RooStats::AcceptanceRegion> : new map<int,RooStats::AcceptanceRegion>;
   }
   static void *newArray_maplEintcORooStatscLcLAcceptanceRegiongR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,RooStats::AcceptanceRegion>[nElements] : new map<int,RooStats::AcceptanceRegion>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcORooStatscLcLAcceptanceRegiongR(void *p) {
      delete ((map<int,RooStats::AcceptanceRegion>*)p);
   }
   static void deleteArray_maplEintcORooStatscLcLAcceptanceRegiongR(void *p) {
      delete [] ((map<int,RooStats::AcceptanceRegion>*)p);
   }
   static void destruct_maplEintcORooStatscLcLAcceptanceRegiongR(void *p) {
      typedef map<int,RooStats::AcceptanceRegion> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,RooStats::AcceptanceRegion>

namespace ROOT {
   void maplEintcOpairlEdoublecOdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEintcOpairlEdoublecOdoublegRsPgR_Dictionary();
   static void *new_maplEintcOpairlEdoublecOdoublegRsPgR(void *p = 0);
   static void *newArray_maplEintcOpairlEdoublecOdoublegRsPgR(Long_t size, void *p);
   static void delete_maplEintcOpairlEdoublecOdoublegRsPgR(void *p);
   static void deleteArray_maplEintcOpairlEdoublecOdoublegRsPgR(void *p);
   static void destruct_maplEintcOpairlEdoublecOdoublegRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,pair<double,double> >*)
   {
      map<int,pair<double,double> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,pair<double,double> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,pair<double,double> >", -2, "prec_stl/map", 63,
                  typeid(map<int,pair<double,double> >), DefineBehavior(ptr, ptr),
                  0, &maplEintcOpairlEdoublecOdoublegRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,pair<double,double> >) );
      instance.SetNew(&new_maplEintcOpairlEdoublecOdoublegRsPgR);
      instance.SetNewArray(&newArray_maplEintcOpairlEdoublecOdoublegRsPgR);
      instance.SetDelete(&delete_maplEintcOpairlEdoublecOdoublegRsPgR);
      instance.SetDeleteArray(&deleteArray_maplEintcOpairlEdoublecOdoublegRsPgR);
      instance.SetDestructor(&destruct_maplEintcOpairlEdoublecOdoublegRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,pair<double,double> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,pair<double,double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEintcOpairlEdoublecOdoublegRsPgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const map<int,pair<double,double> >*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOpairlEdoublecOdoublegRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,pair<double,double> > : new map<int,pair<double,double> >;
   }
   static void *newArray_maplEintcOpairlEdoublecOdoublegRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,pair<double,double> >[nElements] : new map<int,pair<double,double> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOpairlEdoublecOdoublegRsPgR(void *p) {
      delete ((map<int,pair<double,double> >*)p);
   }
   static void deleteArray_maplEintcOpairlEdoublecOdoublegRsPgR(void *p) {
      delete [] ((map<int,pair<double,double> >*)p);
   }
   static void destruct_maplEintcOpairlEdoublecOdoublegRsPgR(void *p) {
      typedef map<int,pair<double,double> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,pair<double,double> >

namespace ROOT {
   void maplEstringcOdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEstringcOdoublegR_Dictionary();
   static void *new_maplEstringcOdoublegR(void *p = 0);
   static void *newArray_maplEstringcOdoublegR(Long_t size, void *p);
   static void delete_maplEstringcOdoublegR(void *p);
   static void deleteArray_maplEstringcOdoublegR(void *p);
   static void destruct_maplEstringcOdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,double>*)
   {
      map<string,double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<string,double>", -2, "prec_stl/map", 63,
                  typeid(map<string,double>), DefineBehavior(ptr, ptr),
                  0, &maplEstringcOdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(map<string,double>) );
      instance.SetNew(&new_maplEstringcOdoublegR);
      instance.SetNewArray(&newArray_maplEstringcOdoublegR);
      instance.SetDelete(&delete_maplEstringcOdoublegR);
      instance.SetDeleteArray(&deleteArray_maplEstringcOdoublegR);
      instance.SetDestructor(&destruct_maplEstringcOdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEstringcOdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,double> : new map<string,double>;
   }
   static void *newArray_maplEstringcOdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,double>[nElements] : new map<string,double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcOdoublegR(void *p) {
      delete ((map<string,double>*)p);
   }
   static void deleteArray_maplEstringcOdoublegR(void *p) {
      delete [] ((map<string,double>*)p);
   }
   static void destruct_maplEstringcOdoublegR(void *p) {
      typedef map<string,double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<string,double>

namespace ROOT {
   void vectorlERooAbsPdfmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERooAbsPdfmUgR_Dictionary();
   static void *new_vectorlERooAbsPdfmUgR(void *p = 0);
   static void *newArray_vectorlERooAbsPdfmUgR(Long_t size, void *p);
   static void delete_vectorlERooAbsPdfmUgR(void *p);
   static void deleteArray_vectorlERooAbsPdfmUgR(void *p);
   static void destruct_vectorlERooAbsPdfmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<RooAbsPdf*>*)
   {
      vector<RooAbsPdf*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RooAbsPdf*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RooAbsPdf*>", -2, "prec_stl/vector", 49,
                  typeid(vector<RooAbsPdf*>), DefineBehavior(ptr, ptr),
                  0, &vectorlERooAbsPdfmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RooAbsPdf*>) );
      instance.SetNew(&new_vectorlERooAbsPdfmUgR);
      instance.SetNewArray(&newArray_vectorlERooAbsPdfmUgR);
      instance.SetDelete(&delete_vectorlERooAbsPdfmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlERooAbsPdfmUgR);
      instance.SetDestructor(&destruct_vectorlERooAbsPdfmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<RooAbsPdf*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RooAbsPdf*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlERooAbsPdfmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooAbsPdf*> : new vector<RooAbsPdf*>;
   }
   static void *newArray_vectorlERooAbsPdfmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooAbsPdf*>[nElements] : new vector<RooAbsPdf*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERooAbsPdfmUgR(void *p) {
      delete ((vector<RooAbsPdf*>*)p);
   }
   static void deleteArray_vectorlERooAbsPdfmUgR(void *p) {
      delete [] ((vector<RooAbsPdf*>*)p);
   }
   static void destruct_vectorlERooAbsPdfmUgR(void *p) {
      typedef vector<RooAbsPdf*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<RooAbsPdf*>

namespace ROOT {
   void vectorlERooStatscLcLSamplingSummarygR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERooStatscLcLSamplingSummarygR_Dictionary();
   static void *new_vectorlERooStatscLcLSamplingSummarygR(void *p = 0);
   static void *newArray_vectorlERooStatscLcLSamplingSummarygR(Long_t size, void *p);
   static void delete_vectorlERooStatscLcLSamplingSummarygR(void *p);
   static void deleteArray_vectorlERooStatscLcLSamplingSummarygR(void *p);
   static void destruct_vectorlERooStatscLcLSamplingSummarygR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<RooStats::SamplingSummary>*)
   {
      vector<RooStats::SamplingSummary> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RooStats::SamplingSummary>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RooStats::SamplingSummary>", -2, "prec_stl/vector", 49,
                  typeid(vector<RooStats::SamplingSummary>), DefineBehavior(ptr, ptr),
                  0, &vectorlERooStatscLcLSamplingSummarygR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RooStats::SamplingSummary>) );
      instance.SetNew(&new_vectorlERooStatscLcLSamplingSummarygR);
      instance.SetNewArray(&newArray_vectorlERooStatscLcLSamplingSummarygR);
      instance.SetDelete(&delete_vectorlERooStatscLcLSamplingSummarygR);
      instance.SetDeleteArray(&deleteArray_vectorlERooStatscLcLSamplingSummarygR);
      instance.SetDestructor(&destruct_vectorlERooStatscLcLSamplingSummarygR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<RooStats::SamplingSummary> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RooStats::SamplingSummary>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlERooStatscLcLSamplingSummarygR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooStats::SamplingSummary> : new vector<RooStats::SamplingSummary>;
   }
   static void *newArray_vectorlERooStatscLcLSamplingSummarygR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooStats::SamplingSummary>[nElements] : new vector<RooStats::SamplingSummary>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERooStatscLcLSamplingSummarygR(void *p) {
      delete ((vector<RooStats::SamplingSummary>*)p);
   }
   static void deleteArray_vectorlERooStatscLcLSamplingSummarygR(void *p) {
      delete [] ((vector<RooStats::SamplingSummary>*)p);
   }
   static void destruct_vectorlERooStatscLcLSamplingSummarygR(void *p) {
      typedef vector<RooStats::SamplingSummary> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<RooStats::SamplingSummary>

namespace ROOT {
   void vectorlERooStatscLcLTestStatisticmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlERooStatscLcLTestStatisticmUgR_Dictionary();
   static void *new_vectorlERooStatscLcLTestStatisticmUgR(void *p = 0);
   static void *newArray_vectorlERooStatscLcLTestStatisticmUgR(Long_t size, void *p);
   static void delete_vectorlERooStatscLcLTestStatisticmUgR(void *p);
   static void deleteArray_vectorlERooStatscLcLTestStatisticmUgR(void *p);
   static void destruct_vectorlERooStatscLcLTestStatisticmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<RooStats::TestStatistic*>*)
   {
      vector<RooStats::TestStatistic*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RooStats::TestStatistic*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<RooStats::TestStatistic*>", -2, "prec_stl/vector", 49,
                  typeid(vector<RooStats::TestStatistic*>), DefineBehavior(ptr, ptr),
                  0, &vectorlERooStatscLcLTestStatisticmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<RooStats::TestStatistic*>) );
      instance.SetNew(&new_vectorlERooStatscLcLTestStatisticmUgR);
      instance.SetNewArray(&newArray_vectorlERooStatscLcLTestStatisticmUgR);
      instance.SetDelete(&delete_vectorlERooStatscLcLTestStatisticmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlERooStatscLcLTestStatisticmUgR);
      instance.SetDestructor(&destruct_vectorlERooStatscLcLTestStatisticmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<RooStats::TestStatistic*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<RooStats::TestStatistic*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlERooStatscLcLTestStatisticmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooStats::TestStatistic*> : new vector<RooStats::TestStatistic*>;
   }
   static void *newArray_vectorlERooStatscLcLTestStatisticmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<RooStats::TestStatistic*>[nElements] : new vector<RooStats::TestStatistic*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERooStatscLcLTestStatisticmUgR(void *p) {
      delete ((vector<RooStats::TestStatistic*>*)p);
   }
   static void deleteArray_vectorlERooStatscLcLTestStatisticmUgR(void *p) {
      delete [] ((vector<RooStats::TestStatistic*>*)p);
   }
   static void destruct_vectorlERooStatscLcLTestStatisticmUgR(void *p) {
      typedef vector<RooStats::TestStatistic*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<RooStats::TestStatistic*>

namespace ROOT {
   void vectorlEconstsPRooArgSetmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEconstsPRooArgSetmUgR_Dictionary();
   static void *new_vectorlEconstsPRooArgSetmUgR(void *p = 0);
   static void *newArray_vectorlEconstsPRooArgSetmUgR(Long_t size, void *p);
   static void delete_vectorlEconstsPRooArgSetmUgR(void *p);
   static void deleteArray_vectorlEconstsPRooArgSetmUgR(void *p);
   static void destruct_vectorlEconstsPRooArgSetmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const RooArgSet*>*)
   {
      vector<const RooArgSet*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const RooArgSet*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<const RooArgSet*>", -2, "prec_stl/vector", 49,
                  typeid(vector<const RooArgSet*>), DefineBehavior(ptr, ptr),
                  0, &vectorlEconstsPRooArgSetmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<const RooArgSet*>) );
      instance.SetNew(&new_vectorlEconstsPRooArgSetmUgR);
      instance.SetNewArray(&newArray_vectorlEconstsPRooArgSetmUgR);
      instance.SetDelete(&delete_vectorlEconstsPRooArgSetmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEconstsPRooArgSetmUgR);
      instance.SetDestructor(&destruct_vectorlEconstsPRooArgSetmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const RooArgSet*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<const RooArgSet*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEconstsPRooArgSetmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<const RooArgSet*> : new vector<const RooArgSet*>;
   }
   static void *newArray_vectorlEconstsPRooArgSetmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<const RooArgSet*>[nElements] : new vector<const RooArgSet*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEconstsPRooArgSetmUgR(void *p) {
      delete ((vector<const RooArgSet*>*)p);
   }
   static void deleteArray_vectorlEconstsPRooArgSetmUgR(void *p) {
      delete [] ((vector<const RooArgSet*>*)p);
   }
   static void destruct_vectorlEconstsPRooArgSetmUgR(void *p) {
      typedef vector<const RooArgSet*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<const RooArgSet*>

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "prec_stl/vector", 49,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintgR_Dictionary();
   static void *new_vectorlEintgR(void *p = 0);
   static void *newArray_vectorlEintgR(Long_t size, void *p);
   static void delete_vectorlEintgR(void *p);
   static void deleteArray_vectorlEintgR(void *p);
   static void destruct_vectorlEintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
   {
      vector<int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "prec_stl/vector", 49,
                  typeid(vector<int>), DefineBehavior(ptr, ptr),
                  0, &vectorlEintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<int>) );
      instance.SetNew(&new_vectorlEintgR);
      instance.SetNewArray(&newArray_vectorlEintgR);
      instance.SetDelete(&delete_vectorlEintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEintgR);
      instance.SetDestructor(&destruct_vectorlEintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete ((vector<int>*)p);
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] ((vector<int>*)p);
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<int>

/********************************************************
* roofit/roostats/src/G__RooStats.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_tagtableG__RooStats();

extern "C" void G__set_cpp_environmentG__RooStats() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("RooStats/AsymptoticCalculator.h");
  G__add_compiledheader("RooStats/BayesianCalculator.h");
  G__add_compiledheader("RooStats/BernsteinCorrection.h");
  G__add_compiledheader("RooStats/CombinedCalculator.h");
  G__add_compiledheader("RooStats/ConfidenceBelt.h");
  G__add_compiledheader("RooStats/ConfInterval.h");
  G__add_compiledheader("RooStats/DebuggingSampler.h");
  G__add_compiledheader("RooStats/DebuggingTestStat.h");
  G__add_compiledheader("RooStats/DetailedOutputAggregator.h");
  G__add_compiledheader("RooStats/FeldmanCousins.h");
  G__add_compiledheader("RooStats/FrequentistCalculator.h");
  G__add_compiledheader("RooStats/Heaviside.h");
  G__add_compiledheader("RooStats/HLFactory.h");
  G__add_compiledheader("RooStats/HybridCalculator.h");
  G__add_compiledheader("RooStats/HybridCalculatorOriginal.h");
  G__add_compiledheader("RooStats/HybridPlot.h");
  G__add_compiledheader("RooStats/HybridResult.h");
  G__add_compiledheader("RooStats/HypoTestCalculatorGeneric.h");
  G__add_compiledheader("RooStats/HypoTestCalculator.h");
  G__add_compiledheader("RooStats/HypoTestInverter.h");
  G__add_compiledheader("RooStats/HypoTestInverterOriginal.h");
  G__add_compiledheader("RooStats/HypoTestInverterPlot.h");
  G__add_compiledheader("RooStats/HypoTestInverterResult.h");
  G__add_compiledheader("RooStats/HypoTestPlot.h");
  G__add_compiledheader("RooStats/HypoTestResult.h");
  G__add_compiledheader("RooStats/IntervalCalculator.h");
  G__add_compiledheader("RooStats/LikelihoodInterval.h");
  G__add_compiledheader("RooStats/LikelihoodIntervalPlot.h");
  G__add_compiledheader("RooStats/MarkovChain.h");
  G__add_compiledheader("RooStats/MaxLikelihoodEstimateTestStat.h");
  G__add_compiledheader("RooStats/MCMCCalculator.h");
  G__add_compiledheader("RooStats/MCMCInterval.h");
  G__add_compiledheader("RooStats/MCMCIntervalPlot.h");
  G__add_compiledheader("RooStats/MetropolisHastings.h");
  G__add_compiledheader("RooStats/MinNLLTestStat.h");
  G__add_compiledheader("RooStats/ModelConfig.h");
  G__add_compiledheader("RooStats/NeymanConstruction.h");
  G__add_compiledheader("RooStats/NumberCountingPdfFactory.h");
  G__add_compiledheader("RooStats/NumberCountingUtils.h");
  G__add_compiledheader("RooStats/NumEventsTestStat.h");
  G__add_compiledheader("RooStats/PdfProposal.h");
  G__add_compiledheader("RooStats/PointSetInterval.h");
  G__add_compiledheader("RooStats/ProfileInspector.h");
  G__add_compiledheader("RooStats/ProfileLikelihoodCalculator.h");
  G__add_compiledheader("RooStats/ProfileLikelihoodTestStat.h");
  G__add_compiledheader("RooStats/ProofConfig.h");
  G__add_compiledheader("RooStats/ProposalFunction.h");
  G__add_compiledheader("RooStats/ProposalHelper.h");
  G__add_compiledheader("RooStats/RatioOfProfiledLikelihoodsTestStat.h");
  G__add_compiledheader("RooStats/RooStatsUtils.h");
  G__add_compiledheader("RooStats/SamplingDistPlot.h");
  G__add_compiledheader("RooStats/SamplingDistribution.h");
  G__add_compiledheader("RooStats/SequentialProposal.h");
  G__add_compiledheader("RooStats/SimpleInterval.h");
  G__add_compiledheader("RooStats/SimpleLikelihoodRatioTestStat.h");
  G__add_compiledheader("RooStats/SPlot.h");
  G__add_compiledheader("RooStats/TestStatistic.h");
  G__add_compiledheader("RooStats/TestStatSampler.h");
  G__add_compiledheader("RooStats/ToyMCImportanceSampler.h");
  G__add_compiledheader("RooStats/ToyMCSampler.h");
  G__add_compiledheader("RooStats/ToyMCStudy.h");
  G__add_compiledheader("RooStats/UniformProposal.h");
  G__add_compiledheader("RooStats/UpperLimitMCSModule.h");
  G__cpp_reset_tagtableG__RooStats();
}
#include <new>
extern "C" int G__cpp_dllrevG__RooStats() { return(30051515); }

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

/* RooStats */
static int G__G__RooStats_109_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::PValueToSignificance((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::SignificanceToPValue((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SetParameters((RooArgSet*) G__int(libp->para[0]), (RooArgSet*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::RemoveConstantParameters((RooArgSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::RemoveConstantParameters(*(RooArgList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) RooStats::SetAllConstant(*(RooAbsCollection*) libp->para[0].ref, (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) RooStats::SetAllConstant(*(RooAbsCollection*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      RooStats::RandomizeCollection(*(RooAbsCollection*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      RooStats::RandomizeCollection(*(RooAbsCollection*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::FactorizePdf(*(RooArgSet*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, *(RooArgList*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::FactorizePdf(*(RooStats::ModelConfig*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, *(RooArgList*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MakeNuisancePdf(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MakeNuisancePdf(*(RooStats::ModelConfig*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) RooStats::MakeUnconstrainedPdf(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) RooStats::MakeUnconstrainedPdf(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) RooStats::MakeUnconstrainedPdf(*(RooStats::ModelConfig*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) RooStats::MakeUnconstrainedPdf(*(RooStats::ModelConfig*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_109_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::GetAsTTree(*((TString*) G__int(libp->para[0])), *((TString*) G__int(libp->para[1]))
, *(RooDataSet*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

static int G__G__RooStats_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->Append((RooStats::HypoTestResult*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->NullPValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->AlternatePValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLsplusb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->Significance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetNullDistribution());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetAltDistribution());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetNullDetailedOutput());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetAltDetailedOutput());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetFitInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetTestStatisticData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetAllTestStatisticsData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->HasTestStatisticData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetAltDistribution((RooStats::SamplingDistribution*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetNullDistribution((RooStats::SamplingDistribution*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetAltDetailedOutput((RooDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetNullDetailedOutput((RooDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetFitInfo((RooDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetTestStatisticData((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetAllTestStatisticsData((RooArgList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetPValueIsRightTail((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetPValueIsRightTail());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetBackgroundAsAlt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HypoTestResult*) G__getstructoffset())->SetBackgroundAsAlt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::HypoTestResult*) G__getstructoffset())->GetBackGroundIsAlt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLbError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLsplusbError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->CLsError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->NullPValueError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_110_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestResult*) G__getstructoffset())->SignificanceError());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* RooStats::ModelConfig */
static int G__G__RooStats_111_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ModelConfig* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ModelConfig((RooWorkspace*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::ModelConfig((RooWorkspace*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::ModelConfig[n];
       } else {
         p = new((void*) gvp) RooStats::ModelConfig[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::ModelConfig;
       } else {
         p = new((void*) gvp) RooStats::ModelConfig;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__RooStats_111_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetWS(*(RooWorkspace*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetWorkspace(*(RooWorkspace*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetProtoData(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetPriorPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetParametersOfInterest(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetParameters((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetParametersOfInterest((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetNuisanceParameters((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetConstraintParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetConstraintParameters((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetObservables((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetConditionalObservables((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetGlobalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetGlobalObservables((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetSnapshot(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetPdf((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetPriorPdf((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->SetProtoData((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetParametersOfInterest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetNuisanceParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetConstraintParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetPriorPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetObservables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetConditionalObservables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetGlobalObservables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetProtoData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetSnapshot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RooStats::ModelConfig*) G__getstructoffset())->LoadSnapshot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetWS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ModelConfig*) G__getstructoffset())->GetWorkspace());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_111_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ModelConfig*) G__getstructoffset())->GuessObsAndNuisance(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* RooStats::HypoTestCalculator */
static int G__G__RooStats_112_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculator*) G__getstructoffset())->GetHypoTest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_112_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculator*) G__getstructoffset())->SetCommonModel(*(RooStats::ModelConfig*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_112_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculator*) G__getstructoffset())->SetNullModel(*(RooStats::ModelConfig*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_112_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculator*) G__getstructoffset())->SetAlternateModel(*(RooStats::ModelConfig*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_112_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculator*) G__getstructoffset())->SetData(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculator*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculator*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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


/* RooStats::TestStatistic */
static int G__G__RooStats_602_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::TestStatistic*) G__getstructoffset())->Evaluate(*(RooAbsData*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_602_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const RooStats::TestStatistic*) G__getstructoffset())->GetVarName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_602_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::TestStatistic*) G__getstructoffset())->PValueIsRightTail());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_602_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::TestStatistic*) G__getstructoffset())->GetDetailedOutput());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_602_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::TestStatistic*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_602_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatistic*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__RooStats_603_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistribution*) G__getstructoffset())->InverseCDF((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistribution*) G__getstructoffset())->InverseCDFInterpolate((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistribution*) G__getstructoffset())->InverseCDF((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistribution*) G__getstructoffset())->Add((RooStats::SamplingDistribution*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::SamplingDistribution*) G__getstructoffset())->GetSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>& obj = ((const RooStats::SamplingDistribution*) G__getstructoffset())->GetSamplingDistribution();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>& obj = ((const RooStats::SamplingDistribution*) G__getstructoffset())->GetSampleWeights();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const RooStats::SamplingDistribution*) G__getstructoffset())->GetVarName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->Integral((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->IntegralAndError(*(Double_t*) G__Doubleref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->IntegralAndError(*(Double_t*) G__Doubleref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->IntegralAndError(*(Double_t*) G__Doubleref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->IntegralAndError(*(Double_t*) G__Doubleref(&libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_603_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::SamplingDistribution*) G__getstructoffset())->CDF((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* RooStats::TestStatSampler */
static int G__G__RooStats_604_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::TestStatSampler*) G__getstructoffset())->GetSamplingDistribution(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::TestStatSampler*) G__getstructoffset())->EvaluateTestStatistic(*(RooAbsData*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::TestStatSampler*) G__getstructoffset())->GetTestStatistic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::TestStatSampler*) G__getstructoffset())->ConfidenceLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->Initialize(*(RooAbsArg*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetPriorNuisance((RooAbsPdf*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetParametersForTestStat(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetGlobalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetTestSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetConfidenceLevel((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetTestStatistic((RooStats::TestStatistic*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->SetSamplingDistName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_604_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::TestStatSampler*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_604_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::TestStatSampler*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_677_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->GetData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_677_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->GetNullModel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_677_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->GetFitInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_677_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->GetAlternateModel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_677_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->GetTestStatSampler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_677_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestCalculatorGeneric*) G__getstructoffset())->UseSameAltToys();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_679_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) RooStats::AsymptoticCalculator::MakeAsimovData(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooArgSet*) libp->para[3].ref
, (RooArgSet*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) RooStats::AsymptoticCalculator::MakeAsimovData(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooArgSet*) libp->para[3].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::AsymptoticCalculator::MakeAsimovData(*(RooStats::ModelConfig*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::AsymptoticCalculator::GenerateAsimovData(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) RooStats::AsymptoticCalculator::GetExpectedPValues((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (bool) G__int(libp->para[3])
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) RooStats::AsymptoticCalculator::GetExpectedPValues((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (bool) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::AsymptoticCalculator*) G__getstructoffset())->SetOneSided((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::AsymptoticCalculator*) G__getstructoffset())->SetTwoSided();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::AsymptoticCalculator*) G__getstructoffset())->SetOneSidedDiscovery((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::AsymptoticCalculator*) G__getstructoffset())->IsTwoSided());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::AsymptoticCalculator*) G__getstructoffset())->IsOneSidedDiscovery());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::AsymptoticCalculator*) G__getstructoffset())->SetQTilde((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooArgSet& obj = ((const RooStats::AsymptoticCalculator*) G__getstructoffset())->GetBestFitPoi();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::AsymptoticCalculator*) G__getstructoffset())->GetMuHat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooArgSet& obj = ((const RooStats::AsymptoticCalculator*) G__getstructoffset())->GetBestFitParams();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_679_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::AsymptoticCalculator::SetPrintLevel((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_684_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::ConfInterval*) G__getstructoffset())->IsInInterval(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_684_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ConfInterval*) G__getstructoffset())->SetConfidenceLevel((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_684_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::ConfInterval*) G__getstructoffset())->ConfidenceLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_684_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ConfInterval*) G__getstructoffset())->GetParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_684_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::ConfInterval*) G__getstructoffset())->CheckParameters(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* RooStats::IntervalCalculator */
static int G__G__RooStats_685_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::IntervalCalculator*) G__getstructoffset())->GetInterval());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::IntervalCalculator*) G__getstructoffset())->Size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::IntervalCalculator*) G__getstructoffset())->ConfidenceLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::IntervalCalculator*) G__getstructoffset())->SetData(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::IntervalCalculator*) G__getstructoffset())->SetModel(*(RooStats::ModelConfig*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::IntervalCalculator*) G__getstructoffset())->SetTestSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::IntervalCalculator*) G__getstructoffset())->SetConfidenceLevel((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_685_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::IntervalCalculator*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_685_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::IntervalCalculator*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_686_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SimpleInterval(*(RooStats::SimpleInterval*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) RooStats::SimpleInterval(*(RooStats::SimpleInterval*) libp->para[0].ref, (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__G__RooStatsLN_RooStatscLcLSimpleInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__RooStats_686_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SimpleInterval(
(const char*) G__int(libp->para[0]), *(RooRealVar*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) RooStats::SimpleInterval(
(const char*) G__int(libp->para[0]), *(RooRealVar*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_686_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::SimpleInterval*) G__getstructoffset())->LowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_686_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::SimpleInterval*) G__getstructoffset())->UpperLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_687_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::BayesianCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::BayesianCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooAbsPdf*) libp->para[3].ref
, (RooArgSet*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::BayesianCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooAbsPdf*) libp->para[3].ref
, (RooArgSet*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::BayesianCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooAbsPdf*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) RooStats::BayesianCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooAbsPdf*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__RooStats_687_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetPosteriorPlot((bool) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetPosteriorPlot((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetPosteriorPlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetPosteriorPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetPosteriorFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetPriorPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetLeftSideTailFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetShortestInterval();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__RooStats_687_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetScanOfPosterior((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetScanOfPosterior();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetNumIters((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->SetIntegrationType((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::BayesianCalculator*) G__getstructoffset())->GetMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_687_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BayesianCalculator*) G__getstructoffset())->ForceNuisancePdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* RooStats::BernsteinCorrection */
static int G__G__RooStats_702_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::BernsteinCorrection* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::BernsteinCorrection((double) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::BernsteinCorrection((double) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::BernsteinCorrection[n];
       } else {
         p = new((void*) gvp) RooStats::BernsteinCorrection[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::BernsteinCorrection;
       } else {
         p = new((void*) gvp) RooStats::BernsteinCorrection;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_702_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::BernsteinCorrection*) G__getstructoffset())->ImportCorrectedPdf((RooWorkspace*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_702_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BernsteinCorrection*) G__getstructoffset())->SetMaxCorrection((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_702_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      ((RooStats::BernsteinCorrection*) G__getstructoffset())->CreateQSamplingDist(
(RooWorkspace*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TH1F*) G__int(libp->para[4]), (TH1F*) 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:
      ((RooStats::BernsteinCorrection*) G__getstructoffset())->CreateQSamplingDist(
(RooWorkspace*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TH1F*) G__int(libp->para[4]), (TH1F*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_702_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::BernsteinCorrection*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_702_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::BernsteinCorrection*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* RooStats::CombinedCalculator */
static int G__G__RooStats_703_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_703_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_703_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_703_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetNullParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_703_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetAlternateParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_703_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::CombinedCalculator*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_704_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingSummaryLookup*) G__getstructoffset())->Add((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_704_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::SamplingSummaryLookup*) G__getstructoffset())->GetLookupIndex((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_713_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::AcceptanceRegion* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::AcceptanceRegion(
(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) RooStats::AcceptanceRegion(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_713_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::AcceptanceRegion*) G__getstructoffset())->GetLookupIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_713_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::AcceptanceRegion*) G__getstructoffset())->GetLowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_713_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::AcceptanceRegion*) G__getstructoffset())->GetUpperLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__RooStats_714_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::SamplingSummary*) G__getstructoffset())->GetParameterPointIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_714_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::SamplingSummary*) G__getstructoffset())->GetSamplingDistribution());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_714_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const RooStats::AcceptanceRegion& obj = ((RooStats::SamplingSummary*) G__getstructoffset())->GetAcceptanceRegion((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const RooStats::AcceptanceRegion& obj = ((RooStats::SamplingSummary*) G__getstructoffset())->GetAcceptanceRegion();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_714_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingSummary*) G__getstructoffset())->AddAcceptanceRegion(*(RooStats::AcceptanceRegion*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__RooStats_722_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ConfidenceBelt* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::ConfidenceBelt((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) RooStats::ConfidenceBelt((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__G__RooStatsLN_RooStatscLcLConfidenceBelt));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__RooStats_722_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, *((RooStats::AcceptanceRegion*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, *((RooStats::AcceptanceRegion*) G__int(libp->para[1]))
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, *((RooStats::AcceptanceRegion*) G__int(libp->para[1])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, (Int_t) G__int(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]));
      G__setnull(result7);
      break;
   case 5:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((RooStats::ConfidenceBelt*) G__getstructoffset())->AddAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegion(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegion(*(RooArgSet*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMin(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMin(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMin(*(RooArgSet*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMax(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMax(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::ConfidenceBelt*) G__getstructoffset())->GetAcceptanceRegionMax(*(RooArgSet*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>* pobj;
         const vector<Double_t> xobj = ((const RooStats::ConfidenceBelt*) G__getstructoffset())->ConfidenceLevels();
         pobj = new vector<Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ConfidenceBelt*) G__getstructoffset())->GetParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_722_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::ConfidenceBelt*) G__getstructoffset())->CheckParameters(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* RooStats::DebuggingSampler */
static int G__G__RooStats_728_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::DebuggingSampler*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__RooStats_735_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      RooStats::ProofConfig::CloseProof((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      RooStats::ProofConfig::CloseProof();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_735_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooWorkspace& obj = ((RooStats::ProofConfig*) G__getstructoffset())->GetWorkspace();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_735_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((RooStats::ProofConfig*) G__getstructoffset())->GetHost());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_735_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::ProofConfig*) G__getstructoffset())->GetNExperiments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_735_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::ProofConfig*) G__getstructoffset())->GetShowGui());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_735_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ProofConfig*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_735_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProofConfig*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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


/* RooStats::DetailedOutputAggregator */
static int G__G__RooStats_736_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) RooStats::DetailedOutputAggregator::GetAsArgSet((RooFitResult*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, (bool) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) RooStats::DetailedOutputAggregator::GetAsArgSet((RooFitResult*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))));
      break;
   case 1:
      G__letint(result7, 85, (long) RooStats::DetailedOutputAggregator::GetAsArgSet((RooFitResult*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__RooStats_736_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->AppendArgSet((RooAbsCollection*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1])));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->AppendArgSet((RooAbsCollection*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_736_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::DetailedOutputAggregator*) G__getstructoffset())->GetAsArgList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_736_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->CommitSet((double) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->CommitSet();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_736_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->GetAsDataSet(*((TString*) G__int(libp->para[0])), *((TString*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__RooStats_736_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::DetailedOutputAggregator*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_736_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::DetailedOutputAggregator*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__RooStats_738_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ToyMCSampler::SetAlwaysUseMultiGen((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetUseMultiGen((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->GetSamplingDistributions(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->GetSamplingDistributionsSingleWorker(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->AppendSamplingDistribution(*(RooArgSet*) libp->para[0].ref, (RooStats::SamplingDistribution*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->AddTestStatistic((RooStats::TestStatistic*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->AddTestStatistic();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCSampler*) G__getstructoffset())->GenerateToyData(*(RooArgSet*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCSampler*) G__getstructoffset())->GenerateToyData(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCSampler*) G__getstructoffset())->GenerateToyData(*(RooArgSet*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])
, *(RooAbsPdf*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCSampler*) G__getstructoffset())->GenerateToyData(*(RooArgSet*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RooStats::ToyMCSampler*) G__getstructoffset())->GenerateGlobalObservables(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::ToyMCSampler*) G__getstructoffset())->EvaluateTestStatistic(*(RooAbsData*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->EvaluateAllTestStatistics(*(RooAbsData*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCSampler*) G__getstructoffset())->GetTestStatistic((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->GetNToys());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetNToys((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetNEventsPerToy((const Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetTestStatistic((RooStats::TestStatistic*) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetExpectedNuisancePar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetExpectedNuisancePar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetAsimovNuisancePar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetAsimovNuisancePar();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::ToyMCSampler*) G__getstructoffset())->CheckConfig());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateBinned((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateBinned();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateBinnedTag((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateBinnedTag();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateAutoBinned((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetGenerateAutoBinned();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__RooStats_738_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetMaxToys((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetToysLeftTail((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetToysRightTail((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetToysBothTails((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetProofConfig((RooStats::ProofConfig*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetProofConfig();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_738_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCSampler*) G__getstructoffset())->SetProtoData((RooDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__RooStats_754_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::DebuggingTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::DebuggingTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::DebuggingTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::DebuggingTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::DebuggingTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::DebuggingTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_754_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::DebuggingTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::DebuggingTestStat G__TRooStatscLcLDebuggingTestStat;
static int G__G__RooStats_754_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::DebuggingTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::DebuggingTestStat*) (soff+(sizeof(RooStats::DebuggingTestStat)*i)))->~G__TRooStatscLcLDebuggingTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::DebuggingTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::DebuggingTestStat*) (soff))->~G__TRooStatscLcLDebuggingTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_754_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::DebuggingTestStat* dest = (RooStats::DebuggingTestStat*) G__getstructoffset();
   *dest = *(RooStats::DebuggingTestStat*) libp->para[0].ref;
   const RooStats::DebuggingTestStat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::PointSetInterval */
static int G__G__RooStats_755_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PointSetInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::PointSetInterval((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::PointSetInterval((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::PointSetInterval[n];
       } else {
         p = new((void*) gvp) RooStats::PointSetInterval[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::PointSetInterval;
       } else {
         p = new((void*) gvp) RooStats::PointSetInterval;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PointSetInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::PointSetInterval((const char*) G__int(libp->para[0]), *(RooAbsData*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::PointSetInterval((const char*) G__int(libp->para[0]), *(RooAbsData*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::PointSetInterval*) G__getstructoffset())->GetParameterPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::PointSetInterval*) G__getstructoffset())->LowerLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::PointSetInterval*) G__getstructoffset())->UpperLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::PointSetInterval::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PointSetInterval::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::PointSetInterval::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::PointSetInterval::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PointSetInterval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PointSetInterval::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::PointSetInterval::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PointSetInterval::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_755_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::PointSetInterval::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_755_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::PointSetInterval* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::PointSetInterval(*(RooStats::PointSetInterval*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::PointSetInterval G__TRooStatscLcLPointSetInterval;
static int G__G__RooStats_755_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[] (RooStats::PointSetInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::PointSetInterval*) (soff+(sizeof(RooStats::PointSetInterval)*i)))->~G__TRooStatscLcLPointSetInterval();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::PointSetInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::PointSetInterval*) (soff))->~G__TRooStatscLcLPointSetInterval();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_755_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PointSetInterval* dest = (RooStats::PointSetInterval*) G__getstructoffset();
   *dest = *(RooStats::PointSetInterval*) libp->para[0].ref;
   const RooStats::PointSetInterval& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::FeldmanCousins */
static int G__G__RooStats_756_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::FeldmanCousins* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::FeldmanCousins(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::FeldmanCousins(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetParameterPointsToTest(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetPOIPointsToTest(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::FeldmanCousins*) G__getstructoffset())->GetPointsToScan());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::FeldmanCousins*) G__getstructoffset())->GetConfidenceBelt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->UseAdaptiveSampling((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->UseAdaptiveSampling();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->AdditionalNToysFactor((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SetNBins((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->FluctuateNumDataEntries((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->FluctuateNumDataEntries();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SaveBeltToFile((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->SaveBeltToFile();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->CreateConfBelt((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::FeldmanCousins*) G__getstructoffset())->CreateConfBelt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::FeldmanCousins*) G__getstructoffset())->GetTestStatSampler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::FeldmanCousins::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FeldmanCousins::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::FeldmanCousins::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::FeldmanCousins::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FeldmanCousins*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FeldmanCousins::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::FeldmanCousins::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FeldmanCousins::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_756_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::FeldmanCousins::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_756_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::FeldmanCousins* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::FeldmanCousins(*(RooStats::FeldmanCousins*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::FeldmanCousins G__TRooStatscLcLFeldmanCousins;
static int G__G__RooStats_756_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::FeldmanCousins*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::FeldmanCousins*) (soff+(sizeof(RooStats::FeldmanCousins)*i)))->~G__TRooStatscLcLFeldmanCousins();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::FeldmanCousins*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::FeldmanCousins*) (soff))->~G__TRooStatscLcLFeldmanCousins();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::FrequentistCalculator */
static int G__G__RooStats_764_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::FrequentistCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::FrequentistCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooStats::TestStatSampler*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::FrequentistCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooStats::TestStatSampler*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::FrequentistCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::FrequentistCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->SetToys((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->SetNToysInTails((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->SetConditionalMLEsNull((RooArgSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->SetConditionalMLEsAlt((RooArgSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->StoreFitInfo((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->StoreFitInfo();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::FrequentistCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FrequentistCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::FrequentistCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::FrequentistCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::FrequentistCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FrequentistCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::FrequentistCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::FrequentistCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_764_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::FrequentistCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_764_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::FrequentistCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::FrequentistCalculator(*(RooStats::FrequentistCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::FrequentistCalculator G__TRooStatscLcLFrequentistCalculator;
static int G__G__RooStats_764_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::FrequentistCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::FrequentistCalculator*) (soff+(sizeof(RooStats::FrequentistCalculator)*i)))->~G__TRooStatscLcLFrequentistCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::FrequentistCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::FrequentistCalculator*) (soff))->~G__TRooStatscLcLFrequentistCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::Heaviside */
static int G__G__RooStats_767_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::Heaviside* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::Heaviside[n];
     } else {
       p = new((void*) gvp) RooStats::Heaviside[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::Heaviside;
     } else {
       p = new((void*) gvp) RooStats::Heaviside;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::Heaviside* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::Heaviside(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooAbsReal*) libp->para[2].ref, *(RooAbsReal*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) RooStats::Heaviside(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooAbsReal*) libp->para[2].ref, *(RooAbsReal*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::Heaviside* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::Heaviside(*(RooStats::Heaviside*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::Heaviside(*(RooStats::Heaviside*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::Heaviside(*(RooStats::Heaviside*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooStats::Heaviside(*(RooStats::Heaviside*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::Heaviside::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::Heaviside::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::Heaviside::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::Heaviside::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::Heaviside*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::Heaviside::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::Heaviside::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::Heaviside::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_767_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::Heaviside::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::Heaviside G__TRooStatscLcLHeaviside;
static int G__G__RooStats_767_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::Heaviside*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::Heaviside*) (soff+(sizeof(RooStats::Heaviside)*i)))->~G__TRooStatscLcLHeaviside();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::Heaviside*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::Heaviside*) (soff))->~G__TRooStatscLcLHeaviside();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HLFactory */
static int G__G__RooStats_769_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HLFactory* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HLFactory(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HLFactory((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::HLFactory((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HLFactory* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory(
(const char*) G__int(libp->para[0]), (RooWorkspace*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HLFactory(
(const char*) G__int(libp->para[0]), (RooWorkspace*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory((const char*) G__int(libp->para[0]), (RooWorkspace*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HLFactory((const char*) G__int(libp->para[0]), (RooWorkspace*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HLFactory* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory[n];
     } else {
       p = new((void*) gvp) RooStats::HLFactory[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HLFactory;
     } else {
       p = new((void*) gvp) RooStats::HLFactory;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((RooStats::HLFactory*) G__getstructoffset())->AddChannel((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((RooStats::HLFactory*) G__getstructoffset())->AddChannel((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((RooStats::HLFactory*) G__getstructoffset())->AddChannel((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HLFactory*) G__getstructoffset())->DumpCfg((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HLFactory*) G__getstructoffset())->GetTotSigBkgPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HLFactory*) G__getstructoffset())->GetTotBkgPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HLFactory*) G__getstructoffset())->GetTotDataSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HLFactory*) G__getstructoffset())->GetTotCategory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HLFactory*) G__getstructoffset())->GetWs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::HLFactory*) G__getstructoffset())->ProcessCard((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HLFactory::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HLFactory::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HLFactory::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HLFactory::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HLFactory*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HLFactory::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HLFactory::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HLFactory::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_769_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HLFactory::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HLFactory G__TRooStatscLcLHLFactory;
static int G__G__RooStats_769_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HLFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HLFactory*) (soff+(sizeof(RooStats::HLFactory)*i)))->~G__TRooStatscLcLHLFactory();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HLFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HLFactory*) (soff))->~G__TRooStatscLcLHLFactory();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HybridCalculator */
static int G__G__RooStats_770_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooStats::TestStatSampler*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooStats::TestStatSampler*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HybridCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculator*) G__getstructoffset())->ForcePriorNuisanceNull(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculator*) G__getstructoffset())->ForcePriorNuisanceAlt(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculator*) G__getstructoffset())->SetToys((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculator*) G__getstructoffset())->SetNToysInTails((int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HybridCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HybridCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HybridCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_770_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_770_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HybridCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HybridCalculator(*(RooStats::HybridCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HybridCalculator G__TRooStatscLcLHybridCalculator;
static int G__G__RooStats_770_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HybridCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HybridCalculator*) (soff+(sizeof(RooStats::HybridCalculator)*i)))->~G__TRooStatscLcLHybridCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HybridCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HybridCalculator*) (soff))->~G__TRooStatscLcLHybridCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HybridPlot */
static int G__G__RooStats_771_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]), (int) G__int(libp->para[5])
, (bool) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) RooStats::HybridPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]), (int) G__int(libp->para[5])
, (bool) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]), (int) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) RooStats::HybridPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref, *(vector<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]), (int) G__int(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridPlot*) G__getstructoffset())->DumpToFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetBmean());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetBrms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetBhisto());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetBCenter((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetBCenter((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetBCenter());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetBIntExtremes((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBmean());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBCenter((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBCenter((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBCenter());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBrms());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBIntExtremes((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetSBhisto());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetCanvas());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridPlot*) G__getstructoffset())->DumpToImage((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetHistoCenter((TH1*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (bool) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetHistoCenter((TH1*) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetHistoCenter((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((RooStats::HybridPlot*) G__getstructoffset())->GetHistoPvals((TH1*) G__int(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridPlot*) G__getstructoffset())->GetMedian((TH1*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HybridPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HybridPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HybridPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_771_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_771_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HybridPlot* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HybridPlot(*(RooStats::HybridPlot*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HybridPlot G__TRooStatscLcLHybridPlot;
static int G__G__RooStats_771_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HybridPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HybridPlot*) (soff+(sizeof(RooStats::HybridPlot)*i)))->~G__TRooStatscLcLHybridPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HybridPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HybridPlot*) (soff))->~G__TRooStatscLcLHybridPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_771_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridPlot* dest = (RooStats::HybridPlot*) G__getstructoffset();
   *dest = *(RooStats::HybridPlot*) libp->para[0].ref;
   const RooStats::HybridPlot& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HybridResult */
static int G__G__RooStats_772_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridResult((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::HybridResult((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HybridResult[n];
       } else {
         p = new((void*) gvp) RooStats::HybridResult[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HybridResult;
       } else {
         p = new((void*) gvp) RooStats::HybridResult;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridResult(
(const char*) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (bool) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HybridResult(
(const char*) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (bool) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridResult(
(const char*) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HybridResult(
(const char*) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridResult*) G__getstructoffset())->SetDataTestStatistics((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridResult*) G__getstructoffset())->Add((RooStats::HybridResult*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::HybridResult*) G__getstructoffset())->GetPlot((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridResult*) G__getstructoffset())->PrintMore((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<double>* pobj;
         vector<double> xobj = ((RooStats::HybridResult*) G__getstructoffset())->GetTestStat_sb();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<double>* pobj;
         vector<double> xobj = ((RooStats::HybridResult*) G__getstructoffset())->GetTestStat_b();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HybridResult*) G__getstructoffset())->GetTestStat_data());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HybridResult*) G__getstructoffset())->CLbError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HybridResult*) G__getstructoffset())->CLsplusbError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HybridResult*) G__getstructoffset())->CLsError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HybridResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HybridResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HybridResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_772_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_772_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HybridResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HybridResult(*(RooStats::HybridResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HybridResult G__TRooStatscLcLHybridResult;
static int G__G__RooStats_772_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HybridResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HybridResult*) (soff+(sizeof(RooStats::HybridResult)*i)))->~G__TRooStatscLcLHybridResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HybridResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HybridResult*) (soff))->~G__TRooStatscLcLHybridResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HybridCalculatorOriginal */
static int G__G__RooStats_773_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridCalculatorOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HybridCalculatorOriginal[n];
       } else {
         p = new((void*) gvp) RooStats::HybridCalculatorOriginal[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HybridCalculatorOriginal;
       } else {
         p = new((void*) gvp) RooStats::HybridCalculatorOriginal;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridCalculatorOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgList*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridCalculatorOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]), (int) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5])
, (int) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3])
, (RooAbsPdf*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref, (RooArgSet*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HybridCalculatorOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3])
, (int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3])
, (int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (bool) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HybridCalculatorOriginal(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetCommonPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetNullPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetAlternatePdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetNullParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetAlternateParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetNuisancePdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetNumberOfToys((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const RooStats::HybridCalculatorOriginal*) G__getstructoffset())->GetNumberOfToys());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->UseNuisance((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->UseNuisance();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetGenerateBinned((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetGenerateBinned();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->SetTestStatistic((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HybridCalculatorOriginal*) G__getstructoffset())->Calculate(*(TH1*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HybridCalculatorOriginal*) G__getstructoffset())->Calculate(*(RooAbsData*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HybridCalculatorOriginal*) G__getstructoffset())->Calculate((unsigned int) G__int(libp->para[0]), (bool) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const RooStats::HybridCalculatorOriginal*) G__getstructoffset())->PrintMore((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->PatchSetExtended((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->PatchSetExtended();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HybridCalculatorOriginal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculatorOriginal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HybridCalculatorOriginal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HybridCalculatorOriginal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HybridCalculatorOriginal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculatorOriginal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridCalculatorOriginal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HybridCalculatorOriginal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_773_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HybridCalculatorOriginal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_773_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HybridCalculatorOriginal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HybridCalculatorOriginal(*(RooStats::HybridCalculatorOriginal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HybridCalculatorOriginal G__TRooStatscLcLHybridCalculatorOriginal;
static int G__G__RooStats_773_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[] (RooStats::HybridCalculatorOriginal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HybridCalculatorOriginal*) (soff+(sizeof(RooStats::HybridCalculatorOriginal)*i)))->~G__TRooStatscLcLHybridCalculatorOriginal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HybridCalculatorOriginal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HybridCalculatorOriginal*) (soff))->~G__TRooStatscLcLHybridCalculatorOriginal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HypoTestInverterResult */
static int G__G__RooStats_777_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverterResult((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverterResult((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HypoTestInverterResult[n];
       } else {
         p = new((void*) gvp) RooStats::HypoTestInverterResult[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::HypoTestInverterResult;
       } else {
         p = new((void*) gvp) RooStats::HypoTestInverterResult;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::HypoTestInverterResult(
(const char*) G__int(libp->para[0]), *(RooRealVar*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) RooStats::HypoTestInverterResult(
(const char*) G__int(libp->para[0]), *(RooRealVar*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::HypoTestInverterResult(*(RooStats::HypoTestInverterResult*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) RooStats::HypoTestInverterResult(*(RooStats::HypoTestInverterResult*) libp->para[0].ref, (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__G__RooStatsLN_RooStatscLcLHypoTestInverterResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooStats::HypoTestInverterResult& obj = ((RooStats::HypoTestInverterResult*) G__getstructoffset())->operator=(*(RooStats::HypoTestInverterResult*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->ExclusionCleanup());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->Add(*(RooStats::HypoTestInverterResult*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->Add((Double_t) G__double(libp->para[0]), *(RooStats::HypoTestResult*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetXValue((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetYValue((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetYError((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLsplusb((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLb((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLs((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLsplusbError((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLbError((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->CLsError((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetResult((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetLastYValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetLastXValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetLastYError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetLastResult());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->ArraySize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->FindIndex((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->SetTestSize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->SetCLsCleanupThreshold((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->UseCLs((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->UseCLs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->IsOneSided());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->IsTwoSided());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->LowerLimitEstimatedError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->UpperLimitEstimatedError());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedPValueDist((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetBackgroundTestStatDist((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetSignalAndBackgroundTestStatDist((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetNullTestStatDist((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetAltTestStatDist((int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetLowerLimitDistribution());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetUpperLimitDistribution());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedLowerLimit((double) G__double(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedLowerLimit((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedLowerLimit());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedUpperLimit((double) G__double(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedUpperLimit((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetExpectedUpperLimit());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->FindInterpolatedLimit((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->FindInterpolatedLimit((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->FindInterpolatedLimit((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::HypoTestInverterResult*) G__getstructoffset())->FindInterpolatedLimit((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->SetInterpolationOption((RooStats::HypoTestInverterResult::InterpolOption_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::HypoTestInverterResult*) G__getstructoffset())->GetInterpolationOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HypoTestInverterResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HypoTestInverterResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestInverterResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_777_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HypoTestInverterResult G__TRooStatscLcLHypoTestInverterResult;
static int G__G__RooStats_777_0_64(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[] (RooStats::HypoTestInverterResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HypoTestInverterResult*) (soff+(sizeof(RooStats::HypoTestInverterResult)*i)))->~G__TRooStatscLcLHypoTestInverterResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HypoTestInverterResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HypoTestInverterResult*) (soff))->~G__TRooStatscLcLHypoTestInverterResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HypoTestInverter */
static int G__G__RooStats_783_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter[n];
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter;
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::HypoTestCalculatorGeneric*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooStats::HybridCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooStats::HybridCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::HybridCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::HybridCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::HybridCalculator*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::HybridCalculator*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooStats::FrequentistCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooStats::FrequentistCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::FrequentistCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::FrequentistCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooStats::AsymptoticCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooStats::AsymptoticCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(*(RooStats::AsymptoticCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(*(RooStats::AsymptoticCalculator*) libp->para[0].ref, (RooRealVar*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3])
, (RooStats::HypoTestInverter::ECalculatorType) G__int(libp->para[4]), (double) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3])
, (RooStats::HypoTestInverter::ECalculatorType) G__int(libp->para[4]), (double) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3])
, (RooStats::HypoTestInverter::ECalculatorType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3])
, (RooStats::HypoTestInverter::ECalculatorType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref, (RooRealVar*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverter(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, *(RooStats::ModelConfig*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverter*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetFixedScan((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetAutoScan();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (bool) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunOnePoint((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunOnePoint((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunOnePoint((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunLimit(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunLimit(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunLimit(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->RunLimit(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->UseCLs((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->UseCLs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->GetHypoTestCalculator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetLowerLimitDistribution((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetLowerLimitDistribution((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetLowerLimitDistribution());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetUpperLimitDistribution((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetUpperLimitDistribution((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->GetUpperLimitDistribution());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (TList*) G__int(libp->para[2]), (TList*) G__int(libp->para[3])
, (TList*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (TList*) G__int(libp->para[2]), (TList*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (TList*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions((bool) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->RebuildDistributions());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::HypoTestInverter*) G__getstructoffset())->GetTestStatistic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverter*) G__getstructoffset())->SetTestStatistic(*(RooStats::TestStatistic*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetVerbose((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetVerbose();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetMaximumToys((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverter*) G__getstructoffset())->SetNumErr((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestInverter::SetCloseProof((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HypoTestInverter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HypoTestInverter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestInverter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_783_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HypoTestInverter G__TRooStatscLcLHypoTestInverter;
static int G__G__RooStats_783_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HypoTestInverter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HypoTestInverter*) (soff+(sizeof(RooStats::HypoTestInverter)*i)))->~G__TRooStatscLcLHypoTestInverter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HypoTestInverter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HypoTestInverter*) (soff))->~G__TRooStatscLcLHypoTestInverter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HypoTestInverterOriginal */
static int G__G__RooStats_787_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverterOriginal[n];
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverterOriginal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverterOriginal;
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverterOriginal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterOriginal* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverterOriginal(
*(RooStats::HypoTestCalculator*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverterOriginal(
*(RooStats::HypoTestCalculator*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestInverterOriginal(*(RooStats::HypoTestCalculator*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooStats::HypoTestInverterOriginal(*(RooStats::HypoTestCalculator*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->RunAutoScan((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (unsigned int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->RunAutoScan((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->RunAutoScan((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->RunFixedScan((int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->RunOnePoint((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->UseCLs((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->UseCLs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HypoTestInverterOriginal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterOriginal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HypoTestInverterOriginal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestInverterOriginal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterOriginal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterOriginal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterOriginal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterOriginal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_787_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterOriginal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_787_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HypoTestInverterOriginal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HypoTestInverterOriginal(*(RooStats::HypoTestInverterOriginal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HypoTestInverterOriginal G__TRooStatscLcLHypoTestInverterOriginal;
static int G__G__RooStats_787_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HypoTestInverterOriginal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HypoTestInverterOriginal*) (soff+(sizeof(RooStats::HypoTestInverterOriginal)*i)))->~G__TRooStatscLcLHypoTestInverterOriginal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HypoTestInverterOriginal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HypoTestInverterOriginal*) (soff))->~G__TRooStatscLcLHypoTestInverterOriginal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_787_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterOriginal* dest = (RooStats::HypoTestInverterOriginal*) G__getstructoffset();
   *dest = *(RooStats::HypoTestInverterOriginal*) libp->para[0].ref;
   const RooStats::HypoTestInverterOriginal& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::SamplingDistPlot */
static int G__G__RooStats_789_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SamplingDistPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SamplingDistPlot((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::SamplingDistPlot((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::SamplingDistPlot[n];
       } else {
         p = new((void*) gvp) RooStats::SamplingDistPlot[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::SamplingDistPlot;
       } else {
         p = new((void*) gvp) RooStats::SamplingDistPlot;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SamplingDistPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SamplingDistPlot(
(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) RooStats::SamplingDistPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddSamplingDistribution((RooStats::SamplingDistribution*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddSamplingDistribution((RooStats::SamplingDistribution*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddSamplingDistributionShaded((RooStats::SamplingDistribution*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddSamplingDistributionShaded((RooStats::SamplingDistribution*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddLine((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])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddLine((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]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddTH1((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddTH1((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddTF1((TF1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddTF1((TF1*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->AddTF1((TF1*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLegend((TLegend*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->ApplyDefaultStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineWidth((Width_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineWidth((Width_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineStyle((Style_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLineStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerColor((Color_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerStyle((Style_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerStyle((Style_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerSize((Size_t) G__double(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetMarkerSize((Size_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->RebinDistribution((Int_t) G__int(libp->para[0]), (RooStats::SamplingDistribution*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->RebinDistribution((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetAxisTitle((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetApplyStyle((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RooStats::SamplingDistPlot*) G__getstructoffset())->GetTH1F((RooStats::SamplingDistribution*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::SamplingDistPlot*) G__getstructoffset())->GetTH1F());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLogXaxis((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetLogYaxis((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetXRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->SetYRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->DumpToFile((const char*) G__int(libp->para[0]), (Option_t*) 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:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->DumpToFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->DumpToFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->DumpToFile((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::SamplingDistPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SamplingDistPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::SamplingDistPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SamplingDistPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SamplingDistPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SamplingDistPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SamplingDistPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SamplingDistPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_789_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SamplingDistPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::SamplingDistPlot G__TRooStatscLcLSamplingDistPlot;
static int G__G__RooStats_789_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::SamplingDistPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::SamplingDistPlot*) (soff+(sizeof(RooStats::SamplingDistPlot)*i)))->~G__TRooStatscLcLSamplingDistPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::SamplingDistPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::SamplingDistPlot*) (soff))->~G__TRooStatscLcLSamplingDistPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HypoTestInverterPlot */
static int G__G__RooStats_790_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::HypoTestInverterPlot((RooStats::HypoTestInverterResult*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RooStats::HypoTestInverterPlot((RooStats::HypoTestInverterResult*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::HypoTestInverterPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (RooStats::HypoTestInverterResult*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) RooStats::HypoTestInverterPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (RooStats::HypoTestInverterResult*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakePlot((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakePlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeExpectedPlot((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeExpectedPlot((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeExpectedPlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeTestStatPlot((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (int) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeTestStatPlot((int) G__int(libp->para[0]), (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->MakeTestStatPlot((int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HypoTestInverterPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HypoTestInverterPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestInverterPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestInverterPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestInverterPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_790_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestInverterPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_790_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::HypoTestInverterPlot* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::HypoTestInverterPlot(*(RooStats::HypoTestInverterPlot*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HypoTestInverterPlot G__TRooStatscLcLHypoTestInverterPlot;
static int G__G__RooStats_790_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HypoTestInverterPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HypoTestInverterPlot*) (soff+(sizeof(RooStats::HypoTestInverterPlot)*i)))->~G__TRooStatscLcLHypoTestInverterPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HypoTestInverterPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HypoTestInverterPlot*) (soff))->~G__TRooStatscLcLHypoTestInverterPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_790_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestInverterPlot* dest = (RooStats::HypoTestInverterPlot*) G__getstructoffset();
   *dest = *(RooStats::HypoTestInverterPlot*) libp->para[0].ref;
   const RooStats::HypoTestInverterPlot& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::HypoTestPlot */
static int G__G__RooStats_805_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot[n];
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot;
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot(*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot(*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot(*(RooStats::HypoTestResult*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot(*(RooStats::HypoTestResult*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::HypoTestPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::HypoTestPlot(
*(RooStats::HypoTestResult*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::HypoTestPlot*) G__getstructoffset())->ApplyResult(*(RooStats::HypoTestResult*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::HypoTestPlot*) G__getstructoffset())->ApplyResult(*(RooStats::HypoTestResult*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestPlot*) G__getstructoffset())->ApplyDefaultStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::HypoTestPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::HypoTestPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::HypoTestPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::HypoTestPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::HypoTestPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_805_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::HypoTestPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::HypoTestPlot G__TRooStatscLcLHypoTestPlot;
static int G__G__RooStats_805_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::HypoTestPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::HypoTestPlot*) (soff+(sizeof(RooStats::HypoTestPlot)*i)))->~G__TRooStatscLcLHypoTestPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::HypoTestPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::HypoTestPlot*) (soff))->~G__TRooStatscLcLHypoTestPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::LikelihoodInterval */
static int G__G__RooStats_807_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::LikelihoodInterval((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::LikelihoodInterval((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::LikelihoodInterval[n];
       } else {
         p = new((void*) gvp) RooStats::LikelihoodInterval[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::LikelihoodInterval;
       } else {
         p = new((void*) gvp) RooStats::LikelihoodInterval;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::LikelihoodInterval(
(const char*) G__int(libp->para[0]), (RooAbsReal*) G__int(libp->para[1])
, (RooArgSet*) G__int(libp->para[2]), (RooArgSet*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::LikelihoodInterval(
(const char*) G__int(libp->para[0]), (RooAbsReal*) G__int(libp->para[1])
, (RooArgSet*) G__int(libp->para[2]), (RooArgSet*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::LikelihoodInterval(
(const char*) G__int(libp->para[0]), (RooAbsReal*) G__int(libp->para[1])
, (RooArgSet*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::LikelihoodInterval(
(const char*) G__int(libp->para[0]), (RooAbsReal*) G__int(libp->para[1])
, (RooArgSet*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::LikelihoodInterval*) G__getstructoffset())->LowerLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::LikelihoodInterval*) G__getstructoffset())->LowerLimit(*(RooRealVar*) libp->para[0].ref, *(bool*) G__Boolref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::LikelihoodInterval*) G__getstructoffset())->UpperLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::LikelihoodInterval*) G__getstructoffset())->UpperLimit(*(RooRealVar*) libp->para[0].ref, *(bool*) G__Boolref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::LikelihoodInterval*) G__getstructoffset())->FindLimits(*(RooRealVar*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((RooStats::LikelihoodInterval*) G__getstructoffset())->GetContourPoints(*(RooRealVar*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((RooStats::LikelihoodInterval*) G__getstructoffset())->GetContourPoints(*(RooRealVar*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::LikelihoodInterval*) G__getstructoffset())->GetLikelihoodRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::LikelihoodInterval*) G__getstructoffset())->GetBestFitParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::LikelihoodInterval::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodInterval::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::LikelihoodInterval::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::LikelihoodInterval::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodInterval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodInterval::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::LikelihoodInterval::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodInterval::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_807_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::LikelihoodInterval::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_807_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::LikelihoodInterval* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::LikelihoodInterval(*(RooStats::LikelihoodInterval*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::LikelihoodInterval G__TRooStatscLcLLikelihoodInterval;
static int G__G__RooStats_807_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::LikelihoodInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::LikelihoodInterval*) (soff+(sizeof(RooStats::LikelihoodInterval)*i)))->~G__TRooStatscLcLLikelihoodInterval();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::LikelihoodInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::LikelihoodInterval*) (soff))->~G__TRooStatscLcLLikelihoodInterval();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_807_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodInterval* dest = (RooStats::LikelihoodInterval*) G__getstructoffset();
   *dest = *(RooStats::LikelihoodInterval*) libp->para[0].ref;
   const RooStats::LikelihoodInterval& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::LikelihoodIntervalPlot */
static int G__G__RooStats_823_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodIntervalPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::LikelihoodIntervalPlot[n];
     } else {
       p = new((void*) gvp) RooStats::LikelihoodIntervalPlot[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::LikelihoodIntervalPlot;
     } else {
       p = new((void*) gvp) RooStats::LikelihoodIntervalPlot;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodIntervalPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::LikelihoodIntervalPlot((RooStats::LikelihoodInterval*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RooStats::LikelihoodIntervalPlot((RooStats::LikelihoodInterval*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->GetPlottedObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetLikelihoodInterval((RooStats::LikelihoodInterval*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetPlotParameters((RooArgSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetContourColor((const Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetLineColor((const Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetMaximum((const Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->SetNPoints((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::LikelihoodIntervalPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodIntervalPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::LikelihoodIntervalPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::LikelihoodIntervalPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::LikelihoodIntervalPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodIntervalPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::LikelihoodIntervalPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::LikelihoodIntervalPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_823_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::LikelihoodIntervalPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_823_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::LikelihoodIntervalPlot* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::LikelihoodIntervalPlot(*(RooStats::LikelihoodIntervalPlot*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::LikelihoodIntervalPlot G__TRooStatscLcLLikelihoodIntervalPlot;
static int G__G__RooStats_823_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[] (RooStats::LikelihoodIntervalPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::LikelihoodIntervalPlot*) (soff+(sizeof(RooStats::LikelihoodIntervalPlot)*i)))->~G__TRooStatscLcLLikelihoodIntervalPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::LikelihoodIntervalPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::LikelihoodIntervalPlot*) (soff))->~G__TRooStatscLcLLikelihoodIntervalPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_823_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::LikelihoodIntervalPlot* dest = (RooStats::LikelihoodIntervalPlot*) G__getstructoffset();
   *dest = *(RooStats::LikelihoodIntervalPlot*) libp->para[0].ref;
   const RooStats::LikelihoodIntervalPlot& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MarkovChain */
static int G__G__RooStats_868_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MarkovChain* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MarkovChain[n];
     } else {
       p = new((void*) gvp) RooStats::MarkovChain[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MarkovChain;
     } else {
       p = new((void*) gvp) RooStats::MarkovChain;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MarkovChain* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MarkovChain(*(RooArgSet*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::MarkovChain(*(RooArgSet*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MarkovChain* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MarkovChain(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooArgSet*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) RooStats::MarkovChain(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooArgSet*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RooStats::MarkovChain*) G__getstructoffset())->Add(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::MarkovChain*) G__getstructoffset())->Add(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((RooStats::MarkovChain*) G__getstructoffset())->AddFast(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::MarkovChain*) G__getstructoffset())->AddFast(*(RooArgSet*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::MarkovChain*) G__getstructoffset())->AddWithBurnIn(*(RooStats::MarkovChain*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::MarkovChain*) G__getstructoffset())->AddWithBurnIn(*(RooStats::MarkovChain*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::MarkovChain*) G__getstructoffset())->Add(*(RooStats::MarkovChain*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::MarkovChain*) G__getstructoffset())->Add(*(RooStats::MarkovChain*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MarkovChain*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->Size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->Get((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->Get());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::MarkovChain*) G__getstructoffset())->Weight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::MarkovChain*) G__getstructoffset())->Weight((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::MarkovChain*) G__getstructoffset())->NLL((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::MarkovChain*) G__getstructoffset())->NLL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet((RooArgSet*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(
*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref
, *(RooCmdArg*) libp->para[6].ref, *(RooCmdArg*) libp->para[7].ref));
      break;
   case 7:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(
*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref
, *(RooCmdArg*) libp->para[6].ref));
      break;
   case 6:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataSet(*(RooCmdArg*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsConstDataSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_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) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist((RooArgSet*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(
*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref
, *(RooCmdArg*) libp->para[6].ref, *(RooCmdArg*) libp->para[7].ref));
      break;
   case 7:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(
*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref
, *(RooCmdArg*) libp->para[6].ref));
      break;
   case 6:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref, *(RooCmdArg*) libp->para[5].ref));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref
, *(RooCmdArg*) libp->para[4].ref));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref, *(RooCmdArg*) libp->para[3].ref));
      break;
   case 3:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref
, *(RooCmdArg*) libp->para[2].ref));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref, *(RooCmdArg*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsDataHist(*(RooCmdArg*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsSparseHist((RooAbsCollection*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsSparseHist());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetAsSparseHist(*(RooAbsCollection*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetNLLVar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MarkovChain*) G__getstructoffset())->GetWeightVar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MarkovChain::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MarkovChain::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MarkovChain::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MarkovChain::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MarkovChain*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MarkovChain::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MarkovChain::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MarkovChain::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_868_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MarkovChain::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_868_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MarkovChain* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MarkovChain(*(RooStats::MarkovChain*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MarkovChain G__TRooStatscLcLMarkovChain;
static int G__G__RooStats_868_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::MarkovChain*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MarkovChain*) (soff+(sizeof(RooStats::MarkovChain)*i)))->~G__TRooStatscLcLMarkovChain();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MarkovChain*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MarkovChain*) (soff))->~G__TRooStatscLcLMarkovChain();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_868_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MarkovChain* dest = (RooStats::MarkovChain*) G__getstructoffset();
   *dest = *(RooStats::MarkovChain*) libp->para[0].ref;
   const RooStats::MarkovChain& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MaxLikelihoodEstimateTestStat */
static int G__G__RooStats_921_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MaxLikelihoodEstimateTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MaxLikelihoodEstimateTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::MaxLikelihoodEstimateTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MaxLikelihoodEstimateTestStat;
     } else {
       p = new((void*) gvp) RooStats::MaxLikelihoodEstimateTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MaxLikelihoodEstimateTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MaxLikelihoodEstimateTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::MaxLikelihoodEstimateTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MaxLikelihoodEstimateTestStat*) G__getstructoffset())->PValueIsRightTail((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MaxLikelihoodEstimateTestStat*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MaxLikelihoodEstimateTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MaxLikelihoodEstimateTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MaxLikelihoodEstimateTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MaxLikelihoodEstimateTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MaxLikelihoodEstimateTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MaxLikelihoodEstimateTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MaxLikelihoodEstimateTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MaxLikelihoodEstimateTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_921_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MaxLikelihoodEstimateTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_921_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MaxLikelihoodEstimateTestStat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MaxLikelihoodEstimateTestStat(*(RooStats::MaxLikelihoodEstimateTestStat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MaxLikelihoodEstimateTestStat G__TRooStatscLcLMaxLikelihoodEstimateTestStat;
static int G__G__RooStats_921_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::MaxLikelihoodEstimateTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MaxLikelihoodEstimateTestStat*) (soff+(sizeof(RooStats::MaxLikelihoodEstimateTestStat)*i)))->~G__TRooStatscLcLMaxLikelihoodEstimateTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MaxLikelihoodEstimateTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MaxLikelihoodEstimateTestStat*) (soff))->~G__TRooStatscLcLMaxLikelihoodEstimateTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_921_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MaxLikelihoodEstimateTestStat* dest = (RooStats::MaxLikelihoodEstimateTestStat*) G__getstructoffset();
   *dest = *(RooStats::MaxLikelihoodEstimateTestStat*) libp->para[0].ref;
   const RooStats::MaxLikelihoodEstimateTestStat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ProposalFunction */
static int G__G__RooStats_922_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalFunction*) G__getstructoffset())->Propose(*(RooArgSet*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::ProposalFunction*) G__getstructoffset())->IsSymmetric(*(RooArgSet*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::ProposalFunction*) G__getstructoffset())->GetProposalDensity(*(RooArgSet*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::ProposalFunction*) G__getstructoffset())->CheckParameters(*(RooArgSet*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ProposalFunction::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalFunction::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ProposalFunction::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProposalFunction::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalFunction*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalFunction::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProposalFunction::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalFunction::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_922_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProposalFunction::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ProposalFunction G__TRooStatscLcLProposalFunction;
static int G__G__RooStats_922_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ProposalFunction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ProposalFunction*) (soff+(sizeof(RooStats::ProposalFunction)*i)))->~G__TRooStatscLcLProposalFunction();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ProposalFunction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ProposalFunction*) (soff))->~G__TRooStatscLcLProposalFunction();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_922_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProposalFunction* dest = (RooStats::ProposalFunction*) G__getstructoffset();
   *dest = *(RooStats::ProposalFunction*) libp->para[0].ref;
   const RooStats::ProposalFunction& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MCMCInterval */
static int G__G__RooStats_925_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MCMCInterval((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::MCMCInterval((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::MCMCInterval[n];
       } else {
         p = new((void*) gvp) RooStats::MCMCInterval[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::MCMCInterval;
       } else {
         p = new((void*) gvp) RooStats::MCMCInterval;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MCMCInterval(
(const char*) G__int(libp->para[0]), *(RooArgSet*) libp->para[1].ref
, *(RooStats::MarkovChain*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) RooStats::MCMCInterval(
(const char*) G__int(libp->para[0]), *(RooArgSet*) libp->para[1].ref
, *(RooStats::MarkovChain*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->GetHistCutoff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->GetKeysPdfCutoff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->GetActualConfidenceLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetHistStrict((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetChain(*(RooStats::MarkovChain*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetAxes(*(RooArgList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetAxes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitTailFraction(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitShortest(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitByKeys(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitByHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitBySparseHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->LowerLimitByDataHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimit(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitTailFraction(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitShortest(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitByKeys(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitByHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitBySparseHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->UpperLimitByDataHist(*(RooRealVar*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::MCMCInterval*) G__getstructoffset())->GetKeysMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetNumBurnInSteps((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetUseKeys((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetUseSparseHist((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetUseKeys());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetNumBurnInSteps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetPosteriorHist());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetPosteriorKeysPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetPosteriorKeysProduct());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::MCMCInterval*) G__getstructoffset())->GetDimension());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChain());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsDataSet((RooArgSet*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsDataSet());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsConstDataSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsDataHist((RooArgSet*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsDataHist());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsSparseHist((RooArgSet*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetChainAsSparseHist());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MCMCInterval*) G__getstructoffset())->GetNLLVar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::MCMCInterval*) G__getstructoffset())->GetWeightVar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetEpsilon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetIntervalType((RooStats::MCMCInterval::IntervalType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((RooStats::MCMCInterval*) G__getstructoffset())->GetIntervalType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetLeftSideTailFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->SetDelta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MCMCInterval::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCInterval::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MCMCInterval::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MCMCInterval::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCInterval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCInterval::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCInterval::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCInterval::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_925_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCInterval::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_925_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MCMCInterval* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MCMCInterval(*(RooStats::MCMCInterval*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MCMCInterval G__TRooStatscLcLMCMCInterval;
static int G__G__RooStats_925_0_81(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[] (RooStats::MCMCInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MCMCInterval*) (soff+(sizeof(RooStats::MCMCInterval)*i)))->~G__TRooStatscLcLMCMCInterval();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MCMCInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MCMCInterval*) (soff))->~G__TRooStatscLcLMCMCInterval();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_925_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCInterval* dest = (RooStats::MCMCInterval*) G__getstructoffset();
   *dest = *(RooStats::MCMCInterval*) libp->para[0].ref;
   const RooStats::MCMCInterval& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MCMCCalculator */
static int G__G__RooStats_928_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MCMCCalculator[n];
     } else {
       p = new((void*) gvp) RooStats::MCMCCalculator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MCMCCalculator;
     } else {
       p = new((void*) gvp) RooStats::MCMCCalculator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MCMCCalculator(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::MCMCCalculator(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetPriorPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetChainParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetProposalFunction(*(RooStats::ProposalFunction*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetNumIters((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetNumBurnInSteps((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetNumBins((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetAxes(*(RooArgList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetUseKeys((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetUseSparseHist((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetIntervalType((RooStats::MCMCInterval::IntervalType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetLeftSideTailFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetKeysConfidenceAccuracy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->SetKeysTerminationThreshold((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MCMCCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MCMCCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MCMCCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_928_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_928_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MCMCCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MCMCCalculator(*(RooStats::MCMCCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MCMCCalculator G__TRooStatscLcLMCMCCalculator;
static int G__G__RooStats_928_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::MCMCCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MCMCCalculator*) (soff+(sizeof(RooStats::MCMCCalculator)*i)))->~G__TRooStatscLcLMCMCCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MCMCCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MCMCCalculator*) (soff))->~G__TRooStatscLcLMCMCCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_928_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCCalculator* dest = (RooStats::MCMCCalculator*) G__getstructoffset();
   *dest = *(RooStats::MCMCCalculator*) libp->para[0].ref;
   const RooStats::MCMCCalculator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MCMCIntervalPlot */
static int G__G__RooStats_991_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCIntervalPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MCMCIntervalPlot[n];
     } else {
       p = new((void*) gvp) RooStats::MCMCIntervalPlot[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MCMCIntervalPlot;
     } else {
       p = new((void*) gvp) RooStats::MCMCIntervalPlot;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCIntervalPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MCMCIntervalPlot(*(RooStats::MCMCInterval*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::MCMCIntervalPlot(*(RooStats::MCMCInterval*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->SetMCMCInterval(*(RooStats::MCMCInterval*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->SetLineWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->SetShadeColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->SetShowBurnIn((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawChainScatter(*(RooRealVar*) libp->para[0].ref, *(RooRealVar*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawParameterVsTime(*(RooRealVar*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawNLLVsTime();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawNLLHist((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawNLLHist();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawWeightHist((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->DrawWeightHist();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MCMCIntervalPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCIntervalPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MCMCIntervalPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MCMCIntervalPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MCMCIntervalPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCIntervalPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCIntervalPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MCMCIntervalPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_991_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MCMCIntervalPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_991_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MCMCIntervalPlot* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MCMCIntervalPlot(*(RooStats::MCMCIntervalPlot*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MCMCIntervalPlot G__TRooStatscLcLMCMCIntervalPlot;
static int G__G__RooStats_991_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::MCMCIntervalPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MCMCIntervalPlot*) (soff+(sizeof(RooStats::MCMCIntervalPlot)*i)))->~G__TRooStatscLcLMCMCIntervalPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MCMCIntervalPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MCMCIntervalPlot*) (soff))->~G__TRooStatscLcLMCMCIntervalPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_991_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MCMCIntervalPlot* dest = (RooStats::MCMCIntervalPlot*) G__getstructoffset();
   *dest = *(RooStats::MCMCIntervalPlot*) libp->para[0].ref;
   const RooStats::MCMCIntervalPlot& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MetropolisHastings */
static int G__G__RooStats_992_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MetropolisHastings* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MetropolisHastings[n];
     } else {
       p = new((void*) gvp) RooStats::MetropolisHastings[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MetropolisHastings;
     } else {
       p = new((void*) gvp) RooStats::MetropolisHastings;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MetropolisHastings* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MetropolisHastings(
*(RooAbsReal*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooStats::ProposalFunction*) libp->para[2].ref, (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) RooStats::MetropolisHastings(
*(RooAbsReal*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooStats::ProposalFunction*) libp->para[2].ref, (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::MetropolisHastings*) G__getstructoffset())->ConstructChain());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetChainParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetProposalFunction(*(RooStats::ProposalFunction*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetNumIters((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetNumBurnInSteps((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetFunction(*(RooAbsReal*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetSign((RooStats::MetropolisHastings::FunctionSign) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->SetType((RooStats::MetropolisHastings::FunctionType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MetropolisHastings::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MetropolisHastings::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MetropolisHastings::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MetropolisHastings::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MetropolisHastings*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MetropolisHastings::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MetropolisHastings::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MetropolisHastings::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_992_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MetropolisHastings::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_992_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::MetropolisHastings* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::MetropolisHastings(*(RooStats::MetropolisHastings*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MetropolisHastings G__TRooStatscLcLMetropolisHastings;
static int G__G__RooStats_992_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[] (RooStats::MetropolisHastings*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MetropolisHastings*) (soff+(sizeof(RooStats::MetropolisHastings)*i)))->~G__TRooStatscLcLMetropolisHastings();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MetropolisHastings*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MetropolisHastings*) (soff))->~G__TRooStatscLcLMetropolisHastings();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_992_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MetropolisHastings* dest = (RooStats::MetropolisHastings*) G__getstructoffset();
   *dest = *(RooStats::MetropolisHastings*) libp->para[0].ref;
   const RooStats::MetropolisHastings& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ProfileLikelihoodTestStat */
static int G__G__RooStats_1006_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodTestStat;
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::ProfileLikelihoodTestStat(*(RooAbsPdf*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::ProfileLikelihoodTestStat(*(RooAbsPdf*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetOneSided((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetOneSided();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetOneSidedDiscovery((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetOneSidedDiscovery();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetSigned((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetSigned();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->IsTwoSided());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->IsOneSidedDiscovery());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProfileLikelihoodTestStat::SetAlwaysReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetLOffset((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetLOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetMinimizer((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetStrategy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetPrintLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->EvaluateProfileLikelihood((int) G__int(libp->para[0]), *(RooAbsData*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->EnableDetailedOutput((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->EnableDetailedOutput((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->EnableDetailedOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->SetVarName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->GetPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ProfileLikelihoodTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ProfileLikelihoodTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProfileLikelihoodTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileLikelihoodTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1006_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileLikelihoodTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1006_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ProfileLikelihoodTestStat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ProfileLikelihoodTestStat(*(RooStats::ProfileLikelihoodTestStat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ProfileLikelihoodTestStat G__TRooStatscLcLProfileLikelihoodTestStat;
static int G__G__RooStats_1006_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ProfileLikelihoodTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ProfileLikelihoodTestStat*) (soff+(sizeof(RooStats::ProfileLikelihoodTestStat)*i)))->~G__TRooStatscLcLProfileLikelihoodTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ProfileLikelihoodTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ProfileLikelihoodTestStat*) (soff))->~G__TRooStatscLcLProfileLikelihoodTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::MinNLLTestStat */
static int G__G__RooStats_1008_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MinNLLTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MinNLLTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::MinNLLTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::MinNLLTestStat;
     } else {
       p = new((void*) gvp) RooStats::MinNLLTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MinNLLTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MinNLLTestStat(*(RooAbsPdf*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::MinNLLTestStat(*(RooAbsPdf*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::MinNLLTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::MinNLLTestStat(*(RooStats::MinNLLTestStat*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::MinNLLTestStat(*(RooStats::MinNLLTestStat*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooStats::MinNLLTestStat& obj = ((RooStats::MinNLLTestStat*) G__getstructoffset())->operator=(*(RooStats::MinNLLTestStat*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetOneSided((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetOneSided();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetOneSidedDiscovery((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetOneSidedDiscovery();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetMinimizer((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetStrategy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetPrintLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetLOffset((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetLOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->EnableDetailedOutput((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->EnableDetailedOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->SetVarName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::MinNLLTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MinNLLTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::MinNLLTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::MinNLLTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::MinNLLTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MinNLLTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MinNLLTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::MinNLLTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1008_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::MinNLLTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::MinNLLTestStat G__TRooStatscLcLMinNLLTestStat;
static int G__G__RooStats_1008_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::MinNLLTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::MinNLLTestStat*) (soff+(sizeof(RooStats::MinNLLTestStat)*i)))->~G__TRooStatscLcLMinNLLTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::MinNLLTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::MinNLLTestStat*) (soff))->~G__TRooStatscLcLMinNLLTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::NeymanConstruction */
static int G__G__RooStats_1009_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NeymanConstruction* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::NeymanConstruction(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::NeymanConstruction(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetTestStatSampler(*(RooStats::TestStatSampler*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetLeftSideTailFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetLeftSideTailFraction();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetParameterPointsToTest(*(RooAbsData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SetNuisanceParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::NeymanConstruction*) G__getstructoffset())->GetConfidenceBelt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->UseAdaptiveSampling((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->UseAdaptiveSampling();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->AdditionalNToysFactor((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SaveBeltToFile((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->SaveBeltToFile();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->CreateConfBelt((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::NeymanConstruction*) G__getstructoffset())->CreateConfBelt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::NeymanConstruction*) G__getstructoffset())->GetTestStatSampler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::NeymanConstruction::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NeymanConstruction::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::NeymanConstruction::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::NeymanConstruction::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NeymanConstruction*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NeymanConstruction::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NeymanConstruction::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NeymanConstruction::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1009_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NeymanConstruction::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1009_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::NeymanConstruction* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::NeymanConstruction(*(RooStats::NeymanConstruction*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::NeymanConstruction G__TRooStatscLcLNeymanConstruction;
static int G__G__RooStats_1009_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::NeymanConstruction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::NeymanConstruction*) (soff+(sizeof(RooStats::NeymanConstruction)*i)))->~G__TRooStatscLcLNeymanConstruction();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::NeymanConstruction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::NeymanConstruction*) (soff))->~G__TRooStatscLcLNeymanConstruction();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::NumberCountingPdfFactory */
static int G__G__RooStats_1010_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NumberCountingPdfFactory* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::NumberCountingPdfFactory[n];
     } else {
       p = new((void*) gvp) RooStats::NumberCountingPdfFactory[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::NumberCountingPdfFactory;
     } else {
       p = new((void*) gvp) RooStats::NumberCountingPdfFactory;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddModel((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (RooWorkspace*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddModel((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (RooWorkspace*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddModel((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (RooWorkspace*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddData((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddData((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddExpData((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddExpData((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddExpDataWithSideband((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddExpDataWithSideband((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddDataWithSideband((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->AddDataWithSideband((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (RooWorkspace*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::NumberCountingPdfFactory::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumberCountingPdfFactory::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::NumberCountingPdfFactory::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::NumberCountingPdfFactory::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::NumberCountingPdfFactory*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NumberCountingPdfFactory*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumberCountingPdfFactory::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NumberCountingPdfFactory::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumberCountingPdfFactory::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1010_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NumberCountingPdfFactory::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1010_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::NumberCountingPdfFactory* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::NumberCountingPdfFactory(*(RooStats::NumberCountingPdfFactory*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::NumberCountingPdfFactory G__TRooStatscLcLNumberCountingPdfFactory;
static int G__G__RooStats_1010_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::NumberCountingPdfFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::NumberCountingPdfFactory*) (soff+(sizeof(RooStats::NumberCountingPdfFactory)*i)))->~G__TRooStatscLcLNumberCountingPdfFactory();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::NumberCountingPdfFactory*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::NumberCountingPdfFactory*) (soff))->~G__TRooStatscLcLNumberCountingPdfFactory();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1010_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NumberCountingPdfFactory* dest = (RooStats::NumberCountingPdfFactory*) G__getstructoffset();
   *dest = *(RooStats::NumberCountingPdfFactory*) libp->para[0].ref;
   const RooStats::NumberCountingPdfFactory& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::NumberCountingUtils */
static int G__G__RooStats_1011_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialExpZ((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__G__RooStats_1011_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialWithTauExpZ((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__G__RooStats_1011_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialObsZ((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__G__RooStats_1011_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialWithTauObsZ((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__G__RooStats_1011_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialExpP((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__G__RooStats_1011_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialWithTauExpP((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__G__RooStats_1011_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialObsP((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__G__RooStats_1011_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) RooStats::NumberCountingUtils::BinomialWithTauObsP((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) ;
}


/* RooStats::NumEventsTestStat */
static int G__G__RooStats_1012_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NumEventsTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::NumEventsTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::NumEventsTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::NumEventsTestStat;
     } else {
       p = new((void*) gvp) RooStats::NumEventsTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NumEventsTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::NumEventsTestStat(*(RooAbsPdf*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::NumEventsTestStat(*(RooAbsPdf*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::NumEventsTestStat*) G__getstructoffset())->GetTestStatistic());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::NumEventsTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumEventsTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::NumEventsTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::NumEventsTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::NumEventsTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumEventsTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NumEventsTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::NumEventsTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1012_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::NumEventsTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1012_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::NumEventsTestStat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::NumEventsTestStat(*(RooStats::NumEventsTestStat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::NumEventsTestStat G__TRooStatscLcLNumEventsTestStat;
static int G__G__RooStats_1012_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::NumEventsTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::NumEventsTestStat*) (soff+(sizeof(RooStats::NumEventsTestStat)*i)))->~G__TRooStatscLcLNumEventsTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::NumEventsTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::NumEventsTestStat*) (soff))->~G__TRooStatscLcLNumEventsTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1012_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::NumEventsTestStat* dest = (RooStats::NumEventsTestStat*) G__getstructoffset();
   *dest = *(RooStats::NumEventsTestStat*) libp->para[0].ref;
   const RooStats::NumEventsTestStat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::PdfProposal */
static int G__G__RooStats_1013_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PdfProposal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::PdfProposal[n];
     } else {
       p = new((void*) gvp) RooStats::PdfProposal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::PdfProposal;
     } else {
       p = new((void*) gvp) RooStats::PdfProposal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PdfProposal* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::PdfProposal(*(RooAbsPdf*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::PdfProposal(*(RooAbsPdf*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::PdfProposal*) G__getstructoffset())->GetPdf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->AddMapping(*(RooRealVar*) libp->para[0].ref, *(RooAbsReal*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->printMappings();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->SetCacheSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->SetOwnsPdf((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::PdfProposal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PdfProposal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::PdfProposal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::PdfProposal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::PdfProposal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PdfProposal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::PdfProposal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::PdfProposal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1013_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::PdfProposal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1013_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::PdfProposal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::PdfProposal(*(RooStats::PdfProposal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::PdfProposal G__TRooStatscLcLPdfProposal;
static int G__G__RooStats_1013_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[] (RooStats::PdfProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::PdfProposal*) (soff+(sizeof(RooStats::PdfProposal)*i)))->~G__TRooStatscLcLPdfProposal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::PdfProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::PdfProposal*) (soff))->~G__TRooStatscLcLPdfProposal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1013_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::PdfProposal* dest = (RooStats::PdfProposal*) G__getstructoffset();
   *dest = *(RooStats::PdfProposal*) libp->para[0].ref;
   const RooStats::PdfProposal& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ProfileInspector */
static int G__G__RooStats_1023_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileInspector* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileInspector[n];
     } else {
       p = new((void*) gvp) RooStats::ProfileInspector[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileInspector;
     } else {
       p = new((void*) gvp) RooStats::ProfileInspector;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ProfileInspector*) G__getstructoffset())->GetListOfProfilePlots(*(RooAbsData*) libp->para[0].ref, (RooStats::ModelConfig*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ProfileInspector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileInspector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ProfileInspector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProfileInspector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ProfileInspector*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileInspector*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileInspector*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileInspector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileInspector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileInspector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileInspector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1023_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileInspector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1023_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ProfileInspector* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ProfileInspector(*(RooStats::ProfileInspector*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ProfileInspector G__TRooStatscLcLProfileInspector;
static int G__G__RooStats_1023_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ProfileInspector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ProfileInspector*) (soff+(sizeof(RooStats::ProfileInspector)*i)))->~G__TRooStatscLcLProfileInspector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ProfileInspector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ProfileInspector*) (soff))->~G__TRooStatscLcLProfileInspector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1023_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileInspector* dest = (RooStats::ProfileInspector*) G__getstructoffset();
   *dest = *(RooStats::ProfileInspector*) libp->para[0].ref;
   const RooStats::ProfileInspector& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ProfileLikelihoodCalculator */
static int G__G__RooStats_1024_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator[n];
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator;
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (RooArgSet*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (RooArgSet*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodCalculator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator(
*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProfileLikelihoodCalculator(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooStats::ProfileLikelihoodCalculator(*(RooAbsData*) libp->para[0].ref, *(RooStats::ModelConfig*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ProfileLikelihoodCalculator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodCalculator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ProfileLikelihoodCalculator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProfileLikelihoodCalculator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProfileLikelihoodCalculator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodCalculator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileLikelihoodCalculator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProfileLikelihoodCalculator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1024_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProfileLikelihoodCalculator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1024_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ProfileLikelihoodCalculator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ProfileLikelihoodCalculator(*(RooStats::ProfileLikelihoodCalculator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ProfileLikelihoodCalculator G__TRooStatscLcLProfileLikelihoodCalculator;
static int G__G__RooStats_1024_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ProfileLikelihoodCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ProfileLikelihoodCalculator*) (soff+(sizeof(RooStats::ProfileLikelihoodCalculator)*i)))->~G__TRooStatscLcLProfileLikelihoodCalculator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ProfileLikelihoodCalculator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ProfileLikelihoodCalculator*) (soff))->~G__TRooStatscLcLProfileLikelihoodCalculator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1024_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProfileLikelihoodCalculator* dest = (RooStats::ProfileLikelihoodCalculator*) G__getstructoffset();
   *dest = *(RooStats::ProfileLikelihoodCalculator*) libp->para[0].ref;
   const RooStats::ProfileLikelihoodCalculator& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::UniformProposal */
static int G__G__RooStats_1025_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::UniformProposal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::UniformProposal[n];
     } else {
       p = new((void*) gvp) RooStats::UniformProposal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::UniformProposal;
     } else {
       p = new((void*) gvp) RooStats::UniformProposal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::UniformProposal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UniformProposal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::UniformProposal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::UniformProposal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::UniformProposal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UniformProposal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::UniformProposal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UniformProposal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1025_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::UniformProposal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1025_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::UniformProposal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::UniformProposal(*(RooStats::UniformProposal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::UniformProposal G__TRooStatscLcLUniformProposal;
static int G__G__RooStats_1025_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::UniformProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::UniformProposal*) (soff+(sizeof(RooStats::UniformProposal)*i)))->~G__TRooStatscLcLUniformProposal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::UniformProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::UniformProposal*) (soff))->~G__TRooStatscLcLUniformProposal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1025_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::UniformProposal* dest = (RooStats::UniformProposal*) G__getstructoffset();
   *dest = *(RooStats::UniformProposal*) libp->para[0].ref;
   const RooStats::UniformProposal& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ProposalHelper */
static int G__G__RooStats_1026_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ProposalHelper* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProposalHelper[n];
     } else {
       p = new((void*) gvp) RooStats::ProposalHelper[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ProposalHelper;
     } else {
       p = new((void*) gvp) RooStats::ProposalHelper;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetPdf(*(RooAbsPdf*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetClues(*(RooDataSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ProposalHelper*) G__getstructoffset())->GetProposalFunction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetCacheSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetUpdateProposalParameters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetVariables(*(RooArgList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetVariables(*(RooArgList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetUniformFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetCluesFraction((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetCovMatrix(*(TMatrixDSym*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetWidthRangeDivisor((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetCluesOptions((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->SetVariables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ProposalHelper::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalHelper::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ProposalHelper::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ProposalHelper::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ProposalHelper*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalHelper::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProposalHelper::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ProposalHelper::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1026_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ProposalHelper::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1026_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ProposalHelper* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ProposalHelper(*(RooStats::ProposalHelper*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ProposalHelper G__TRooStatscLcLProposalHelper;
static int G__G__RooStats_1026_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ProposalHelper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ProposalHelper*) (soff+(sizeof(RooStats::ProposalHelper)*i)))->~G__TRooStatscLcLProposalHelper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ProposalHelper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ProposalHelper*) (soff))->~G__TRooStatscLcLProposalHelper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::RatioOfProfiledLikelihoodsTestStat */
static int G__G__RooStats_1027_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::RatioOfProfiledLikelihoodsTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::RatioOfProfiledLikelihoodsTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::RatioOfProfiledLikelihoodsTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::RatioOfProfiledLikelihoodsTestStat;
     } else {
       p = new((void*) gvp) RooStats::RatioOfProfiledLikelihoodsTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::RatioOfProfiledLikelihoodsTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::RatioOfProfiledLikelihoodsTestStat(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, (RooArgSet*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) RooStats::RatioOfProfiledLikelihoodsTestStat(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, (RooArgSet*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::RatioOfProfiledLikelihoodsTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) RooStats::RatioOfProfiledLikelihoodsTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->ProfiledLikelihood(*(RooAbsData*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooAbsPdf*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->EnableDetailedOutput((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->EnableDetailedOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::RatioOfProfiledLikelihoodsTestStat::SetAlwaysReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetMinimizer((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetStrategy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetTolerance((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetPrintLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->SetSubtractMLE((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::RatioOfProfiledLikelihoodsTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::RatioOfProfiledLikelihoodsTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1027_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::RatioOfProfiledLikelihoodsTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1027_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::RatioOfProfiledLikelihoodsTestStat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::RatioOfProfiledLikelihoodsTestStat(*(RooStats::RatioOfProfiledLikelihoodsTestStat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::RatioOfProfiledLikelihoodsTestStat G__TRooStatscLcLRatioOfProfiledLikelihoodsTestStat;
static int G__G__RooStats_1027_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::RatioOfProfiledLikelihoodsTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::RatioOfProfiledLikelihoodsTestStat*) (soff+(sizeof(RooStats::RatioOfProfiledLikelihoodsTestStat)*i)))->~G__TRooStatscLcLRatioOfProfiledLikelihoodsTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::RatioOfProfiledLikelihoodsTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::RatioOfProfiledLikelihoodsTestStat*) (soff))->~G__TRooStatscLcLRatioOfProfiledLikelihoodsTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::SequentialProposal */
static int G__G__RooStats_1028_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SequentialProposal* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SequentialProposal[n];
     } else {
       p = new((void*) gvp) RooStats::SequentialProposal[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SequentialProposal;
     } else {
       p = new((void*) gvp) RooStats::SequentialProposal;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SequentialProposal* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SequentialProposal((double) G__double(libp->para[0]));
   } else {
     p = new((void*) gvp) RooStats::SequentialProposal((double) G__double(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::SequentialProposal::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SequentialProposal::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::SequentialProposal::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SequentialProposal::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SequentialProposal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SequentialProposal::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SequentialProposal::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SequentialProposal::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1028_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SequentialProposal::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1028_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::SequentialProposal* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::SequentialProposal(*(RooStats::SequentialProposal*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::SequentialProposal G__TRooStatscLcLSequentialProposal;
static int G__G__RooStats_1028_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::SequentialProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::SequentialProposal*) (soff+(sizeof(RooStats::SequentialProposal)*i)))->~G__TRooStatscLcLSequentialProposal();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::SequentialProposal*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::SequentialProposal*) (soff))->~G__TRooStatscLcLSequentialProposal();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1028_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SequentialProposal* dest = (RooStats::SequentialProposal*) G__getstructoffset();
   *dest = *(RooStats::SequentialProposal*) libp->para[0].ref;
   const RooStats::SequentialProposal& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::SimpleLikelihoodRatioTestStat */
static int G__G__RooStats_1029_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleLikelihoodRatioTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SimpleLikelihoodRatioTestStat[n];
     } else {
       p = new((void*) gvp) RooStats::SimpleLikelihoodRatioTestStat[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SimpleLikelihoodRatioTestStat;
     } else {
       p = new((void*) gvp) RooStats::SimpleLikelihoodRatioTestStat;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleLikelihoodRatioTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SimpleLikelihoodRatioTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) RooStats::SimpleLikelihoodRatioTestStat(*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleLikelihoodRatioTestStat* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SimpleLikelihoodRatioTestStat(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooArgSet*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) RooStats::SimpleLikelihoodRatioTestStat(
*(RooAbsPdf*) libp->para[0].ref, *(RooAbsPdf*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, *(RooArgSet*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SimpleLikelihoodRatioTestStat::SetAlwaysReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->SetReuseNLL((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->SetNullParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->SetAltParameters(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->ParamsAreEqual());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->EnableDetailedOutput((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->EnableDetailedOutput();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::SimpleLikelihoodRatioTestStat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SimpleLikelihoodRatioTestStat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::SimpleLikelihoodRatioTestStat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SimpleLikelihoodRatioTestStat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SimpleLikelihoodRatioTestStat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SimpleLikelihoodRatioTestStat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SimpleLikelihoodRatioTestStat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1029_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SimpleLikelihoodRatioTestStat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1029_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::SimpleLikelihoodRatioTestStat* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::SimpleLikelihoodRatioTestStat(*(RooStats::SimpleLikelihoodRatioTestStat*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::SimpleLikelihoodRatioTestStat G__TRooStatscLcLSimpleLikelihoodRatioTestStat;
static int G__G__RooStats_1029_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::SimpleLikelihoodRatioTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::SimpleLikelihoodRatioTestStat*) (soff+(sizeof(RooStats::SimpleLikelihoodRatioTestStat)*i)))->~G__TRooStatscLcLSimpleLikelihoodRatioTestStat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::SimpleLikelihoodRatioTestStat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::SimpleLikelihoodRatioTestStat*) (soff))->~G__TRooStatscLcLSimpleLikelihoodRatioTestStat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1029_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SimpleLikelihoodRatioTestStat* dest = (RooStats::SimpleLikelihoodRatioTestStat*) G__getstructoffset();
   *dest = *(RooStats::SimpleLikelihoodRatioTestStat*) libp->para[0].ref;
   const RooStats::SimpleLikelihoodRatioTestStat& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::SPlot */
static int G__G__RooStats_1031_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot[n];
     } else {
       p = new((void*) gvp) RooStats::SPlot[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot;
     } else {
       p = new((void*) gvp) RooStats::SPlot;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SPlot(*(RooStats::SPlot*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::SPlot(*(RooStats::SPlot*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SPlot((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) RooStats::SPlot((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__G__RooStatsLN_RooStatscLcLSPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]), (bool) G__int(libp->para[7])
, (const char*) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]), (bool) 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 RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]), (bool) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]), (bool) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref
, (bool) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref);
     } else {
       p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref, *(RooArgSet*) libp->para[5].ref);
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref);
     } else {
       p = new((void*) gvp) RooStats::SPlot(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(RooDataSet*) libp->para[2].ref, (RooAbsPdf*) G__int(libp->para[3])
, *(RooArgList*) libp->para[4].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::SPlot*) G__getstructoffset())->SetSData((RooDataSet*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::SPlot*) G__getstructoffset())->GetSDataSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const RooArgList* pobj;
         const RooArgList xobj = ((const RooStats::SPlot*) G__getstructoffset())->GetSWeightVars();
         pobj = new RooArgList(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const RooStats::SPlot*) G__getstructoffset())->GetNumSWeightVars());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((RooStats::SPlot*) G__getstructoffset())->AddSWeight((RooAbsPdf*) G__int(libp->para[0]), *(RooArgList*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref, (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((RooStats::SPlot*) G__getstructoffset())->AddSWeight((RooAbsPdf*) G__int(libp->para[0]), *(RooArgList*) libp->para[1].ref
, *(RooArgSet*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((RooStats::SPlot*) G__getstructoffset())->AddSWeight((RooAbsPdf*) G__int(libp->para[0]), *(RooArgList*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::SPlot*) G__getstructoffset())->GetSumOfEventSWeight((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::SPlot*) G__getstructoffset())->GetYieldFromSWeight((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const RooStats::SPlot*) G__getstructoffset())->GetSWeight((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::SPlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SPlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::SPlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::SPlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::SPlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SPlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SPlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::SPlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1031_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::SPlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::SPlot G__TRooStatscLcLSPlot;
static int G__G__RooStats_1031_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::SPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::SPlot*) (soff+(sizeof(RooStats::SPlot)*i)))->~G__TRooStatscLcLSPlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::SPlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::SPlot*) (soff))->~G__TRooStatscLcLSPlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1031_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::SPlot* dest = (RooStats::SPlot*) G__getstructoffset();
   *dest = *(RooStats::SPlot*) libp->para[0].ref;
   const RooStats::SPlot& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ToyMCImportanceSampler */
static int G__G__RooStats_1034_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCImportanceSampler* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCImportanceSampler[n];
     } else {
       p = new((void*) gvp) RooStats::ToyMCImportanceSampler[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCImportanceSampler;
     } else {
       p = new((void*) gvp) RooStats::ToyMCImportanceSampler;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCImportanceSampler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::ToyMCImportanceSampler(*(RooStats::TestStatistic*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) RooStats::ToyMCImportanceSampler(*(RooStats::TestStatistic*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCImportanceSampler*) G__getstructoffset())->GenerateToyData(*(RooArgSet*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])
, *(vector<double>*) libp->para[2].ref, *(double*) G__Doubleref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCImportanceSampler*) G__getstructoffset())->GenerateToyData(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const RooStats::ToyMCImportanceSampler*) G__getstructoffset())->GenerateToyData(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetDensityToGenerateFromByIndex((unsigned int) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetDensityToGenerateFromByIndex((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->AddImportanceDensity((RooAbsPdf*) G__int(libp->para[0]), (RooArgSet*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->AddNullDensity((RooAbsPdf*) G__int(libp->para[0]), (RooArgSet*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->AddNullDensity((RooAbsPdf*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetApplyVeto((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetApplyVeto();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetReuseNLL((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetReuseNLL();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetConditionalObservables(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->CreateNImpDensitiesForOnePOI(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooRealVar*) libp->para[2].ref, (int) G__int(libp->para[3])
, (double) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->CreateNImpDensitiesForOnePOI(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooRealVar*) libp->para[2].ref, (int) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_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) ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->CreateImpDensitiesForOnePOIAdaptively(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooRealVar*) libp->para[2].ref, (double) G__double(libp->para[3])
, (double) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->CreateImpDensitiesForOnePOIAdaptively(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooRealVar*) libp->para[2].ref, (double) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->CreateImpDensitiesForOnePOIAdaptively(*(RooAbsPdf*) libp->para[0].ref, *(RooArgSet*) libp->para[1].ref
, *(RooRealVar*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetEqualNumToysPerDensity();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->SetExpIncreasingNumToysPerDensity();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ToyMCImportanceSampler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCImportanceSampler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ToyMCImportanceSampler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ToyMCImportanceSampler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCImportanceSampler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCImportanceSampler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCImportanceSampler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCImportanceSampler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1034_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCImportanceSampler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1034_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ToyMCImportanceSampler* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ToyMCImportanceSampler(*(RooStats::ToyMCImportanceSampler*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ToyMCImportanceSampler G__TRooStatscLcLToyMCImportanceSampler;
static int G__G__RooStats_1034_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ToyMCImportanceSampler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ToyMCImportanceSampler*) (soff+(sizeof(RooStats::ToyMCImportanceSampler)*i)))->~G__TRooStatscLcLToyMCImportanceSampler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ToyMCImportanceSampler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ToyMCImportanceSampler*) (soff))->~G__TRooStatscLcLToyMCImportanceSampler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ToyMCStudy */
static int G__G__RooStats_1042_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCStudy* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCStudy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::ToyMCStudy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCStudy((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::ToyMCStudy((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::ToyMCStudy[n];
       } else {
         p = new((void*) gvp) RooStats::ToyMCStudy[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new RooStats::ToyMCStudy;
       } else {
         p = new((void*) gvp) RooStats::ToyMCStudy;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCStudy*) G__getstructoffset())->merge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCStudy*) G__getstructoffset())->SetToyMCSampler(*(RooStats::ToyMCSampler*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCStudy*) G__getstructoffset())->SetParamPoint(*(RooArgSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ToyMCStudy::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCStudy::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ToyMCStudy::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ToyMCStudy::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCStudy*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCStudy::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCStudy::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCStudy::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1042_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCStudy::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1042_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ToyMCStudy* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ToyMCStudy(*(RooStats::ToyMCStudy*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ToyMCStudy G__TRooStatscLcLToyMCStudy;
static int G__G__RooStats_1042_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ToyMCStudy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ToyMCStudy*) (soff+(sizeof(RooStats::ToyMCStudy)*i)))->~G__TRooStatscLcLToyMCStudy();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ToyMCStudy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ToyMCStudy*) (soff))->~G__TRooStatscLcLToyMCStudy();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1042_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCStudy* dest = (RooStats::ToyMCStudy*) G__getstructoffset();
   *dest = *(RooStats::ToyMCStudy*) libp->para[0].ref;
   const RooStats::ToyMCStudy& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::ToyMCPayload */
static int G__G__RooStats_1043_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCPayload* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCPayload[n];
     } else {
       p = new((void*) gvp) RooStats::ToyMCPayload[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::ToyMCPayload;
     } else {
       p = new((void*) gvp) RooStats::ToyMCPayload;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCPayload* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::ToyMCPayload((RooDataSet*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) RooStats::ToyMCPayload((RooDataSet*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((RooStats::ToyMCPayload*) G__getstructoffset())->GetSamplingDistributions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::ToyMCPayload::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCPayload::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::ToyMCPayload::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::ToyMCPayload::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::ToyMCPayload*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCPayload::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCPayload::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::ToyMCPayload::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1043_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::ToyMCPayload::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__RooStats_1043_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   RooStats::ToyMCPayload* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new RooStats::ToyMCPayload(*(RooStats::ToyMCPayload*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::ToyMCPayload G__TRooStatscLcLToyMCPayload;
static int G__G__RooStats_1043_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::ToyMCPayload*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::ToyMCPayload*) (soff+(sizeof(RooStats::ToyMCPayload)*i)))->~G__TRooStatscLcLToyMCPayload();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::ToyMCPayload*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::ToyMCPayload*) (soff))->~G__TRooStatscLcLToyMCPayload();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__RooStats_1043_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::ToyMCPayload* dest = (RooStats::ToyMCPayload*) G__getstructoffset();
   *dest = *(RooStats::ToyMCPayload*) libp->para[0].ref;
   const RooStats::ToyMCPayload& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* RooStats::UpperLimitMCSModule */
static int G__G__RooStats_1049_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::UpperLimitMCSModule* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::UpperLimitMCSModule((RooArgSet*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) RooStats::UpperLimitMCSModule((RooArgSet*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new RooStats::UpperLimitMCSModule((RooArgSet*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) RooStats::UpperLimitMCSModule((RooArgSet*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   RooStats::UpperLimitMCSModule* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new RooStats::UpperLimitMCSModule(*(RooStats::UpperLimitMCSModule*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) RooStats::UpperLimitMCSModule(*(RooStats::UpperLimitMCSModule*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) RooStats::UpperLimitMCSModule::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UpperLimitMCSModule::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) RooStats::UpperLimitMCSModule::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      RooStats::UpperLimitMCSModule::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((RooStats::UpperLimitMCSModule*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UpperLimitMCSModule::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::UpperLimitMCSModule::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) RooStats::UpperLimitMCSModule::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__RooStats_1049_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) RooStats::UpperLimitMCSModule::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef RooStats::UpperLimitMCSModule G__TRooStatscLcLUpperLimitMCSModule;
static int G__G__RooStats_1049_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (RooStats::UpperLimitMCSModule*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((RooStats::UpperLimitMCSModule*) (soff+(sizeof(RooStats::UpperLimitMCSModule)*i)))->~G__TRooStatscLcLUpperLimitMCSModule();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (RooStats::UpperLimitMCSModule*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((RooStats::UpperLimitMCSModule*) (soff))->~G__TRooStatscLcLUpperLimitMCSModule();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* RooStats */

/* RooStats::HypoTestResult */

/* RooStats::ModelConfig */

/* RooStats::HypoTestCalculator */

/* RooStats::TestStatistic */

/* RooStats::SamplingDistribution */

/* RooStats::TestStatSampler */

/* RooStats::HypoTestCalculatorGeneric */

/* RooStats::AsymptoticCalculator */

/* RooStats::ConfInterval */

/* RooStats::IntervalCalculator */

/* RooStats::SimpleInterval */

/* RooStats::BayesianCalculator */

/* RooStats::BernsteinCorrection */

/* RooStats::CombinedCalculator */

/* RooStats::SamplingSummaryLookup */

/* RooStats::AcceptanceRegion */

/* RooStats::SamplingSummary */

/* RooStats::ConfidenceBelt */

/* RooStats::DebuggingSampler */

/* RooStats::ProofConfig */

/* RooStats::DetailedOutputAggregator */

/* RooStats::ToyMCSampler */

/* RooStats::DebuggingTestStat */

/* RooStats::PointSetInterval */

/* RooStats::FeldmanCousins */

/* RooStats::FrequentistCalculator */

/* RooStats::Heaviside */

/* RooStats::HLFactory */

/* RooStats::HybridCalculator */

/* RooStats::HybridPlot */

/* RooStats::HybridResult */

/* RooStats::HybridCalculatorOriginal */

/* RooStats::HypoTestInverterResult */

/* RooStats::HypoTestInverter */

/* RooStats::HypoTestInverterOriginal */

/* RooStats::SamplingDistPlot */

/* RooStats::HypoTestInverterPlot */

/* RooStats::HypoTestPlot */

/* RooStats::LikelihoodInterval */

/* RooStats::LikelihoodIntervalPlot */

/* RooStats::MarkovChain */

/* RooStats::MaxLikelihoodEstimateTestStat */

/* RooStats::ProposalFunction */

/* RooStats::MCMCInterval */

/* RooStats::MCMCCalculator */

/* RooStats::MCMCIntervalPlot */

/* RooStats::MetropolisHastings */

/* RooStats::ProfileLikelihoodTestStat */

/* RooStats::MinNLLTestStat */

/* RooStats::NeymanConstruction */

/* RooStats::NumberCountingPdfFactory */

/* RooStats::NumberCountingUtils */

/* RooStats::NumEventsTestStat */

/* RooStats::PdfProposal */

/* RooStats::ProfileInspector */

/* RooStats::ProfileLikelihoodCalculator */

/* RooStats::UniformProposal */

/* RooStats::ProposalHelper */

/* RooStats::RatioOfProfiledLikelihoodsTestStat */

/* RooStats::SequentialProposal */

/* RooStats::SimpleLikelihoodRatioTestStat */

/* RooStats::SPlot */

/* RooStats::ToyMCImportanceSampler */

/* RooStats::ToyMCStudy */

/* RooStats::ToyMCPayload */

/* RooStats::UpperLimitMCSModule */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__RooStats {
 public:
  G__Sizep2memfuncG__RooStats(): p(&G__Sizep2memfuncG__RooStats::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__RooStats::*p)();
};

size_t G__get_sizep2memfuncG__RooStats()
{
  G__Sizep2memfuncG__RooStats 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_inheritanceG__RooStats() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult))) {
     RooStats::HypoTestResult *G__Lderived;
     G__Lderived=(RooStats::HypoTestResult*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig))) {
     RooStats::ModelConfig *G__Lderived;
     G__Lderived=(RooStats::ModelConfig*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution))) {
     RooStats::SamplingDistribution *G__Lderived;
     G__Lderived=(RooStats::SamplingDistribution*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric))) {
     RooStats::HypoTestCalculatorGeneric *G__Lderived;
     G__Lderived=(RooStats::HypoTestCalculatorGeneric*)0x1000;
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator))) {
     RooStats::AsymptoticCalculator *G__Lderived;
     G__Lderived=(RooStats::AsymptoticCalculator*)0x1000;
     {
       RooStats::HypoTestCalculatorGeneric *G__Lpbase=(RooStats::HypoTestCalculatorGeneric*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval))) {
     RooStats::ConfInterval *G__Lderived;
     G__Lderived=(RooStats::ConfInterval*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval))) {
     RooStats::SimpleInterval *G__Lderived;
     G__Lderived=(RooStats::SimpleInterval*)0x1000;
     {
       RooStats::ConfInterval *G__Lpbase=(RooStats::ConfInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator))) {
     RooStats::BayesianCalculator *G__Lderived;
     G__Lderived=(RooStats::BayesianCalculator*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator))) {
     RooStats::CombinedCalculator *G__Lderived;
     G__Lderived=(RooStats::CombinedCalculator*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup))) {
     RooStats::SamplingSummaryLookup *G__Lderived;
     G__Lderived=(RooStats::SamplingSummaryLookup*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion))) {
     RooStats::AcceptanceRegion *G__Lderived;
     G__Lderived=(RooStats::AcceptanceRegion*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary))) {
     RooStats::SamplingSummary *G__Lderived;
     G__Lderived=(RooStats::SamplingSummary*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt))) {
     RooStats::ConfidenceBelt *G__Lderived;
     G__Lderived=(RooStats::ConfidenceBelt*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler))) {
     RooStats::DebuggingSampler *G__Lderived;
     G__Lderived=(RooStats::DebuggingSampler*)0x1000;
     {
       RooStats::TestStatSampler *G__Lpbase=(RooStats::TestStatSampler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler))) {
     RooStats::ToyMCSampler *G__Lderived;
     G__Lderived=(RooStats::ToyMCSampler*)0x1000;
     {
       RooStats::TestStatSampler *G__Lpbase=(RooStats::TestStatSampler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat))) {
     RooStats::DebuggingTestStat *G__Lderived;
     G__Lderived=(RooStats::DebuggingTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval))) {
     RooStats::PointSetInterval *G__Lderived;
     G__Lderived=(RooStats::PointSetInterval*)0x1000;
     {
       RooStats::ConfInterval *G__Lpbase=(RooStats::ConfInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins))) {
     RooStats::FeldmanCousins *G__Lderived;
     G__Lderived=(RooStats::FeldmanCousins*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator))) {
     RooStats::FrequentistCalculator *G__Lderived;
     G__Lderived=(RooStats::FrequentistCalculator*)0x1000;
     {
       RooStats::HypoTestCalculatorGeneric *G__Lpbase=(RooStats::HypoTestCalculatorGeneric*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside))) {
     RooStats::Heaviside *G__Lderived;
     G__Lderived=(RooStats::Heaviside*)0x1000;
     {
       RooAbsReal *G__Lpbase=(RooAbsReal*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooAbsArg *G__Lpbase=(RooAbsArg*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsArg),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooPrintable *G__Lpbase=(RooPrintable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),G__get_linked_tagnum(&G__G__RooStatsLN_RooPrintable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory))) {
     RooStats::HLFactory *G__Lderived;
     G__Lderived=(RooStats::HLFactory*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator))) {
     RooStats::HybridCalculator *G__Lderived;
     G__Lderived=(RooStats::HybridCalculator*)0x1000;
     {
       RooStats::HypoTestCalculatorGeneric *G__Lpbase=(RooStats::HypoTestCalculatorGeneric*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot))) {
     RooStats::HybridPlot *G__Lderived;
     G__Lderived=(RooStats::HybridPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult))) {
     RooStats::HybridResult *G__Lderived;
     G__Lderived=(RooStats::HybridResult*)0x1000;
     {
       RooStats::HypoTestResult *G__Lpbase=(RooStats::HypoTestResult*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal))) {
     RooStats::HybridCalculatorOriginal *G__Lderived;
     G__Lderived=(RooStats::HybridCalculatorOriginal*)0x1000;
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult))) {
     RooStats::HypoTestInverterResult *G__Lderived;
     G__Lderived=(RooStats::HypoTestInverterResult*)0x1000;
     {
       RooStats::SimpleInterval *G__Lpbase=(RooStats::SimpleInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::ConfInterval *G__Lpbase=(RooStats::ConfInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter))) {
     RooStats::HypoTestInverter *G__Lderived;
     G__Lderived=(RooStats::HypoTestInverter*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal))) {
     RooStats::HypoTestInverterOriginal *G__Lderived;
     G__Lderived=(RooStats::HypoTestInverterOriginal*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot))) {
     RooStats::SamplingDistPlot *G__Lderived;
     G__Lderived=(RooStats::SamplingDistPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooPrintable *G__Lpbase=(RooPrintable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot),G__get_linked_tagnum(&G__G__RooStatsLN_RooPrintable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot))) {
     RooStats::HypoTestInverterPlot *G__Lderived;
     G__Lderived=(RooStats::HypoTestInverterPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot))) {
     RooStats::HypoTestPlot *G__Lderived;
     G__Lderived=(RooStats::HypoTestPlot*)0x1000;
     {
       RooStats::SamplingDistPlot *G__Lpbase=(RooStats::SamplingDistPlot*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooPrintable *G__Lpbase=(RooPrintable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot),G__get_linked_tagnum(&G__G__RooStatsLN_RooPrintable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval))) {
     RooStats::LikelihoodInterval *G__Lderived;
     G__Lderived=(RooStats::LikelihoodInterval*)0x1000;
     {
       RooStats::ConfInterval *G__Lpbase=(RooStats::ConfInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot))) {
     RooStats::LikelihoodIntervalPlot *G__Lderived;
     G__Lderived=(RooStats::LikelihoodIntervalPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooPrintable *G__Lpbase=(RooPrintable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_RooPrintable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain))) {
     RooStats::MarkovChain *G__Lderived;
     G__Lderived=(RooStats::MarkovChain*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat))) {
     RooStats::MaxLikelihoodEstimateTestStat *G__Lderived;
     G__Lderived=(RooStats::MaxLikelihoodEstimateTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction))) {
     RooStats::ProposalFunction *G__Lderived;
     G__Lderived=(RooStats::ProposalFunction*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval))) {
     RooStats::MCMCInterval *G__Lderived;
     G__Lderived=(RooStats::MCMCInterval*)0x1000;
     {
       RooStats::ConfInterval *G__Lpbase=(RooStats::ConfInterval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator))) {
     RooStats::MCMCCalculator *G__Lderived;
     G__Lderived=(RooStats::MCMCCalculator*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot))) {
     RooStats::MCMCIntervalPlot *G__Lderived;
     G__Lderived=(RooStats::MCMCIntervalPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooPrintable *G__Lpbase=(RooPrintable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot),G__get_linked_tagnum(&G__G__RooStatsLN_RooPrintable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings))) {
     RooStats::MetropolisHastings *G__Lderived;
     G__Lderived=(RooStats::MetropolisHastings*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat))) {
     RooStats::ProfileLikelihoodTestStat *G__Lderived;
     G__Lderived=(RooStats::ProfileLikelihoodTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat))) {
     RooStats::MinNLLTestStat *G__Lderived;
     G__Lderived=(RooStats::MinNLLTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction))) {
     RooStats::NeymanConstruction *G__Lderived;
     G__Lderived=(RooStats::NeymanConstruction*)0x1000;
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat))) {
     RooStats::NumEventsTestStat *G__Lderived;
     G__Lderived=(RooStats::NumEventsTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal))) {
     RooStats::PdfProposal *G__Lderived;
     G__Lderived=(RooStats::PdfProposal*)0x1000;
     {
       RooStats::ProposalFunction *G__Lpbase=(RooStats::ProposalFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator))) {
     RooStats::ProfileLikelihoodCalculator *G__Lderived;
     G__Lderived=(RooStats::ProfileLikelihoodCalculator*)0x1000;
     {
       RooStats::CombinedCalculator *G__Lpbase=(RooStats::CombinedCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::IntervalCalculator *G__Lpbase=(RooStats::IntervalCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       RooStats::HypoTestCalculator *G__Lpbase=(RooStats::HypoTestCalculator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal))) {
     RooStats::UniformProposal *G__Lderived;
     G__Lderived=(RooStats::UniformProposal*)0x1000;
     {
       RooStats::ProposalFunction *G__Lpbase=(RooStats::ProposalFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper))) {
     RooStats::ProposalHelper *G__Lderived;
     G__Lderived=(RooStats::ProposalHelper*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat))) {
     RooStats::RatioOfProfiledLikelihoodsTestStat *G__Lderived;
     G__Lderived=(RooStats::RatioOfProfiledLikelihoodsTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal))) {
     RooStats::SequentialProposal *G__Lderived;
     G__Lderived=(RooStats::SequentialProposal*)0x1000;
     {
       RooStats::ProposalFunction *G__Lpbase=(RooStats::ProposalFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat))) {
     RooStats::SimpleLikelihoodRatioTestStat *G__Lderived;
     G__Lderived=(RooStats::SimpleLikelihoodRatioTestStat*)0x1000;
     {
       RooStats::TestStatistic *G__Lpbase=(RooStats::TestStatistic*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot))) {
     RooStats::SPlot *G__Lderived;
     G__Lderived=(RooStats::SPlot*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler))) {
     RooStats::ToyMCImportanceSampler *G__Lderived;
     G__Lderived=(RooStats::ToyMCImportanceSampler*)0x1000;
     {
       RooStats::ToyMCSampler *G__Lpbase=(RooStats::ToyMCSampler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       RooStats::TestStatSampler *G__Lpbase=(RooStats::TestStatSampler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler),G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy))) {
     RooStats::ToyMCStudy *G__Lderived;
     G__Lderived=(RooStats::ToyMCStudy*)0x1000;
     {
       RooAbsStudy *G__Lpbase=(RooAbsStudy*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy),G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsStudy),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload))) {
     RooStats::ToyMCPayload *G__Lderived;
     G__Lderived=(RooStats::ToyMCPayload*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule))) {
     RooStats::UpperLimitMCSModule *G__Lderived;
     G__Lderived=(RooStats::UpperLimitMCSModule*)0x1000;
     {
       RooAbsMCStudyModule *G__Lpbase=(RooAbsMCStudyModule*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule),G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsMCStudyModule),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule),G__get_linked_tagnum(&G__G__RooStatsLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule),G__get_linked_tagnum(&G__G__RooStatsLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__RooStats() {

   /* 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("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Width_t",115,-1,0,-1);
   G__setnewtype(-1,"Line width (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("Size_t",102,-1,0,-1);
   G__setnewtype(-1,"Attribute size (float)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   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__G__RooStatsLN_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__G__RooStatsLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStatsLN_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__G__RooStatsLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<string,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,string,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<std::pair<RooAbsArg*,RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<pair<RooAbsArg*,RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<pair<RooAbsArg*,RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<pair<RooAbsArg*,RooAbsArg*>,less<pair<RooAbsArg*,RooAbsArg*> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<RooAbsCache*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_dequelERooAbsCachemUcOallocatorlERooAbsCachemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RooAbsArg*,TRefArray*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooAbsArgmUcOTRefArraymUcOlesslERooAbsArgmUgRcOallocatorlEpairlERooAbsArgmUsPconstcOTRefArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RooAbsArg*,TRefArray*,less<RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooAbsArgmUcOTRefArraymUcOlesslERooAbsArgmUgRcOallocatorlEpairlERooAbsArgmUsPconstcOTRefArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<RooAbsArg*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_dequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<RooAbsArg*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_stacklERooAbsArgmUcOdequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooCurve*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooCurvemUcOallocatorlERooCurvemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooCurvemUcOallocatorlERooCurvemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TH1*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TH1*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TH1*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TH1*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RooDataHist*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataHist*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataHist*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataHist*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RooDataSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooDataSet*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RooAbsData*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooAbsData*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooAbsData*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooAbsData*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<EvalError>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsReal::EvalError>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<std::string,std::list<EvalError> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<string,std::list<EvalError> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,std::pair<std::string,std::list<EvalError> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,std::pair<string,std::list<EvalError> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,pair<string,list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> > > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,pair<string,list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> > >,less<const RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Pair>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<const RooArgSet*,const RooArgSet*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Pair,ULong_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<const RooArgSet*,const RooArgSet*>,unsigned long>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<const RooArgSet*,const RooArgSet*>,unsigned long,less<pair<const RooArgSet*,const RooArgSet*> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,string,less<int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<StreamConfig>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooMsgService::StreamConfig>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_dequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<std::vector<StreamConfig> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<vector<StreamConfig> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,std::ostream*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,std::ostream*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,basic_ostream<char,char_traits<char> >*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,basic_ostream<char,char_traits<char> >*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooNormSetCache>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooAbsCacheElement*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Bool_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TClass*,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETClassmUcOintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TClass*,int,less<TClass*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETClassmUcOintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,int,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSym",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Int_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,int,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,ExpensiveObject*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooExpensiveObjectCache::ExpensiveObject*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooExpensiveObjectCache::ExpensiveObject*,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsData*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsDatamUcOallocatorlERooAbsDatamUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TObject*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlETObjectmUcOallocatorlETObjectmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,ClassRelInfo>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ClassRelInfo>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ClassRelInfo,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,ClassFiles>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ClassFiles>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ClassFiles,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,ExtraHeader>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ExtraHeader>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,RooWorkspace::CodeRepo::ExtraHeader,less<TString> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RooArgSet>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooArgSet>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooArgSet>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooArgSet,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooDataSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooDataSetmUcOallocatorlERooDataSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,RooSharedProperties*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooSharedProperties*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooSharedProperties*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,RooSharedProperties*,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Int_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Int_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<int,allocator<int> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pRooArgSet>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooArgSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooAbsReal*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("AcceptanceCriteria",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEdoublecOdoublegR),0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup));
   G__setnewtype(-1,"defined by Confidence level, leftside tail probability",0);
   G__search_typename2("map<Int_t,AcceptanceCriteria>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,pair<double,double> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,pair<double,double>,less<int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("LookupTable",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup));
   G__setnewtype(-1,"map ( Index, ( CL, leftside tail prob) )",0);
   G__search_typename2("map<Int_t,AcceptanceRegion>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,RooStats::AcceptanceRegion>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,RooStats::AcceptanceRegion,less<int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<SamplingSummary>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooStats::SamplingSummary>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsStudy*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsStudymUcOallocatorlERooAbsStudymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TestStatistic*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooStats::TestStatistic*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsPdf*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooArgSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsPdf::GenSpec*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsPdfcLcLGenSpecmUcOallocatorlERooAbsPdfcLcLGenSpecmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<std::string,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEstringcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<string,int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_pairlEstringcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<std::string,int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<string,int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<string,int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("auto_ptr<HypoTestCalculatorGeneric>",117,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlERooStatscLcLHypoTestCalculatorGenericgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,double,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("auto_ptr<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,std::pair<Double_t,Double_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,pair<double,double> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const RooAbsArg*,pair<double,double>,less<const RooAbsArg*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RooCacheManager<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_RooCacheManagerlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RooCacheManager<vector<Double_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_RooCacheManagerlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> >*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooAbsLValue*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const RooAbsBinning*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooFit::MPSplit>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::Fit::ParameterSettings>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,pair<double,double> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<unsigned int,pair<double,double>,less<unsigned int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooAbsArg*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Bool_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,bool>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,bool,less<int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVectorD>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVectorT<double> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::pair<std::string,int>,BoxInfo*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,int>,BoxInfo*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,int>,RooNDKeysPdf::BoxInfo*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<pair<string,int>,RooNDKeysPdf::BoxInfo*,less<pair<string,int> > >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,bool>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,bool>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,bool>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,bool,less<string> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RooRealVar*,RooAbsReal*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<RooRealVar*,RooAbsReal*,less<RooRealVar*> >",117,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<RooAbsPdf*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const RooArgSet*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<RooAbsMCStudyModule*>",117,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsMCStudyModulemUcOallocatorlERooAbsMCStudyModulemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* RooStats */
static void G__setup_memvarRooStats(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStats));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLtoysStrategies),-1,-2,1,G__FastAllocString(2048).Format("EQUALTOYSPERDENSITY=%lldLL",(long long)RooStats::EQUALTOYSPERDENSITY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLtoysStrategies),-1,-2,1,G__FastAllocString(2048).Format("EXPONENTIALTOYDISTRIBUTION=%lldLL",(long long)RooStats::EXPONENTIALTOYDISTRIBUTION).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestResult */
static void G__setup_memvarRooStatscLcLHypoTestResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult));
   { RooStats::HypoTestResult *p; p=(RooStats::HypoTestResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNullPValue=",0,"p-value for the null hypothesis (small number means disfavored)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlternatePValue=",0,"p-value for the alternate hypothesis (small number means disfavored)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNullPValueError=",0,"error of p-value for the null hypothesis (small number means disfavored)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlternatePValueError=",0,"error of p-value for the alternate hypothesis (small number means disfavored)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTestStatisticData=",0,"result of the test statistic evaluated on data");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,2,"fAllTestStatisticsData=",0,"for the case of multiple test statistics, holds all the results");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution),-1,-1,2,"fNullDistr=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution),-1,-1,2,"fAltDistr=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fNullDetailedOutput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fAltDetailedOutput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fFitInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPValueIsRightTail=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBackgroundIsAlt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ModelConfig */
static void G__setup_memvarRooStatscLcLModelConfig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig));
   { RooStats::ModelConfig *p; p=(RooStats::ModelConfig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TRef),-1,-1,2,"fRefWS=",0,"WS reference used in the file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fWSName=",0,"name of the WS");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fPdfName=",0,"name of  PDF in workspace");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fDataName=",0,"name of data set in workspace");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fPOIName=",0,"name for RooArgSet specifying parameters of interest");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fNuisParamsName=",0,"name for RooArgSet specifying nuisance parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fConstrParamsName=",0,"name for RooArgSet specifying constrained parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fPriorPdfName=",0,"name for RooAbsPdf specifying a prior on the parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fConditionalObsName=",0,"name for RooArgSet specifying conditional observables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fGlobalObsName=",0,"name for RooArgSet specifying global observables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fProtoDataName=",0,"name for RooArgSet specifying dataset that should be used as protodata");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fSnapshotName=",0,"name for RooArgSet that specifies a particular hypothesis");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fObservablesName=",0,"name for RooArgSet specifying observable parameters. ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestCalculator */
static void G__setup_memvarRooStatscLcLHypoTestCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator));
   { RooStats::HypoTestCalculator *p; p=(RooStats::HypoTestCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::TestStatistic */
static void G__setup_memvarRooStatscLcLTestStatistic(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic));
   { RooStats::TestStatistic *p; p=(RooStats::TestStatistic*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SamplingDistribution */
static void G__setup_memvarRooStatscLcLSamplingDistribution(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution));
   { RooStats::SamplingDistribution *p; p=(RooStats::SamplingDistribution*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSamplingDist=",0,"vector of points for the sampling distribution");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSampleWeights=",0,"vector of weights for the samples");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fVarName=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSumW=",0,"! Chached vector with sum of the weight used to compute integral ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSumW2=",0,"! Chached vector with sum of the weight used to compute integral error ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::TestStatSampler */
static void G__setup_memvarRooStatscLcLTestStatSampler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler));
   { RooStats::TestStatSampler *p; p=(RooStats::TestStatSampler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestCalculatorGeneric */
static void G__setup_memvarRooStatscLcLHypoTestCalculatorGeneric(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric));
   { RooStats::HypoTestCalculatorGeneric *p; p=(RooStats::HypoTestCalculatorGeneric*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),-1,-1,2,"fAltModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),-1,-1,2,"fNullModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,2,"fData=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),-1,-1,2,"fTestStatSampler=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),-1,-1,2,"fDefaultSampler=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic),-1,-1,2,"fDefaultTestStat=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fAltToysSeed=",0,"to have same toys for alternate ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::AsymptoticCalculator */
static void G__setup_memvarRooStatscLcLAsymptoticCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator));
   { RooStats::AsymptoticCalculator *p; p=(RooStats::AsymptoticCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fOneSided=",0,"for one sided PL test statistic (upper limits)");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fOneSidedDiscovery=",0,"for one sided PL test statistic (for discovery)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fUseQTilde=",0,"flag to indicate if using qtilde or not (-1 (default based on RooRealVar)), 0 false, 1 (true)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-2,4,"fgPrintLevel=",0,"control print level  (0 minimal, 1 normal, 2 debug)");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fNLLObs=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fNLLAsimov=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fAsimovData=",0,"asimov data set ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fAsimovGlobObs=",0,"snapshot of Asimov global observables ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fBestFitPoi=",0,"snapshot of best fitted POI values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fBestFitParams=",0,"snapshot of all best fitted Parameter values");
   }
   G__tag_memvar_reset();
}


   /* RooStats::ConfInterval */
static void G__setup_memvarRooStatscLcLConfInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval));
   { RooStats::ConfInterval *p; p=(RooStats::ConfInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::IntervalCalculator */
static void G__setup_memvarRooStatscLcLIntervalCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator));
   { RooStats::IntervalCalculator *p; p=(RooStats::IntervalCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SimpleInterval */
static void G__setup_memvarRooStatscLcLSimpleInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval));
   { RooStats::SimpleInterval *p; p=(RooStats::SimpleInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fParameters)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,1,"fParameters=",0,"set containing the parameter of interest");
   G__memvar_setup((void*)((long)(&p->fLowerLimit)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLowerLimit=",0,"lower interval limit");
   G__memvar_setup((void*)((long)(&p->fUpperLimit)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fUpperLimit=",0,"upper interval limit");
   G__memvar_setup((void*)((long)(&p->fConfidenceLevel)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fConfidenceLevel=",0,"confidence level");
   }
   G__tag_memvar_reset();
}


   /* RooStats::BayesianCalculator */
static void G__setup_memvarRooStatscLcLBayesianCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator));
   { RooStats::BayesianCalculator *p; p=(RooStats::BayesianCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fData=",0,"data set ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPdf=",0,"model pdf  (could contain the nuisance pdf as constraint term)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fPOI=",0,"POI");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPriorPdf=",0,"prior pdf (typically for the POI)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fNuisancePdf=",0,"nuisance pdf (needed when using nuisance sampling technique)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fNuisanceParameters=",0,"nuisance parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fConditionalObs=",0,"conditional observables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fProductPdf=",0,"internal pointer to model * prior");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fLogLike=",0,"internal pointer to log likelihood function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fLikelihood=",0,"internal pointer to likelihood function ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fIntegratedLikelihood=",0,"integrated likelihood function, i.e - unnormalized posterior function  ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPosteriorPdf=",0,"normalized (on the poi) posterior pdf ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),G__defined_typename("IGenFunction"),-1,4,"fPosteriorFunction=",0,"function representing the posterior");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TF1),-1,-1,4,"fApproxPosterior=",0,"TF1 representing the scanned posterior function");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLower=",0,"computer lower interval bound");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fUpper=",0,"upper interval bound");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNLLMin=",0,"minimum value of Nll ");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fSize=",0,"size used for getting the interval");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLeftSideFraction=",0,"fraction of probability content on left side of interval");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fBrfPrecision=",0,"root finder precision");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNScanBins=",0,"number of bins to scan, if = -1 no scan is done (default)");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNumIterations=",0,"number of iterations (when using ToyMC)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValidInterval=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fIntegrationType=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::BernsteinCorrection */
static void G__setup_memvarRooStatscLcLBernsteinCorrection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection));
   { RooStats::BernsteinCorrection *p; p=(RooStats::BernsteinCorrection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMaxCorrection=",0,"maximum correction factor at any point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTolerance=",0,"probability to add an unnecessary term");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::CombinedCalculator */
static void G__setup_memvarRooStatscLcLCombinedCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator));
   { RooStats::CombinedCalculator *p; p=(RooStats::CombinedCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSize=",0,"size of the test (eg. specified rate of Type I error)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,2,"fData=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fPOI=",0,"RooArgSet specifying  parameters of interest for interval");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fNullParams=",0,"RooArgSet specifying null parameters for hypothesis test");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fAlternateParams=",0,"RooArgSet specifying alternate parameters for hypothesis test       // Is it used ????");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fNuisParams=",0,"RooArgSet specifying  nuisance parameters for interval");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fConditionalObs=",0,"RooArgSet specifying the conditional observables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SamplingSummaryLookup */
static void G__setup_memvarRooStatscLcLSamplingSummaryLookup(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup));
   { RooStats::SamplingSummaryLookup *p; p=(RooStats::SamplingSummaryLookup*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("LookupTable"),-1,4,"fLookupTable=",0,"map ( Index, ( CL, leftside tail prob) )");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::AcceptanceRegion */
static void G__setup_memvarRooStatscLcLAcceptanceRegion(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion));
   { RooStats::AcceptanceRegion *p; p=(RooStats::AcceptanceRegion*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLookupIndex=",0,"want a small footprint reference to the RooArgSet for particular parameter point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLowerLimit=",0,"lower limit on test statistic");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fUpperLimit=",0,"upper limit on test statistic");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SamplingSummary */
static void G__setup_memvarRooStatscLcLSamplingSummary(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary));
   { RooStats::SamplingSummary *p; p=(RooStats::SamplingSummary*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fParameterPointIndex=",0,"want a small footprint reference to the RooArgSet for particular parameter point");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TRef),-1,-1,4,"fSamplingDistribution=",0,"persistent pointer to a SamplingDistribution");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR),G__defined_typename("map<Int_t,AcceptanceRegion>"),-1,4,"fAcceptanceRegions=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ConfidenceBelt */
static void G__setup_memvarRooStatscLcLConfidenceBelt(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt));
   { RooStats::ConfidenceBelt *p; p=(RooStats::ConfidenceBelt*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup),-1,-1,4,"fSamplingSummaryLookup=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR),G__defined_typename("vector<SamplingSummary>"),-1,4,"fSamplingSummaries=",0,"composite of several AcceptanceRegions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fParameterPoints=",0,"either a histogram (RooDataHist) or a tree (RooDataSet)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::DebuggingSampler */
static void G__setup_memvarRooStatscLcLDebuggingSampler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler));
   { RooStats::DebuggingSampler *p; p=(RooStats::DebuggingSampler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"fTestStatistic=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TRandom),-1,-1,4,"fRand=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProofConfig */
static void G__setup_memvarRooStatscLcLProofConfig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProofConfig));
   { RooStats::ProofConfig *p; p=(RooStats::ProofConfig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace),-1,-1,2,"fWorkspace=",0,"workspace that is to be used with the RooStudyManager");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNExperiments=",0,"number of experiments. This is sometimes called \"events\" in proof; \"experiments\" in RooStudyManager.");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-1,2,"fHost=",0,"Proof hostname. Use empty string (ie \"\") for proof-lite. Can also handle options like \"workers=2\" to run on two nodes.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowGui=",0,"Whether to show the Proof Progress window.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::DetailedOutputAggregator */
static void G__setup_memvarRooStatscLcLDetailedOutputAggregator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator));
   { RooStats::DetailedOutputAggregator *p; p=(RooStats::DetailedOutputAggregator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,4,"fResult=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,4,"fBuiltSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ToyMCSampler */
static void G__setup_memvarRooStatscLcLToyMCSampler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler));
   { RooStats::ToyMCSampler *p; p=(RooStats::ToyMCSampler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPdf=",0,"model (can be alt or null)");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fParametersForTestStat=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR),G__defined_typename("vector<TestStatistic*>"),-1,2,"fTestStatistics=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,2,"fSamplingDistName=",0,"name of the model");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPriorNuisance=",0,"prior pdf for nuisance parameters");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fNuisancePars=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fObservables=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fGlobalObservables=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNToys=",0,"number of toys to generate");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNEvents=",0,"number of events per toy (may be ignored depending on settings)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fExpectedNuisancePar=",0,"whether to use expectation values for nuisance parameters (ie Asimov data set)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGenerateBinned=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,2,"fGenerateBinnedTag=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGenerateAutoBinned=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fToysInTails=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxToys=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAdaptiveLowLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAdaptiveHighLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fProtoData=",0,"in dev");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProofConfig),-1,-1,2,"fProofConfig=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNuisanceParametersSampler),-1,-1,2,"fNuisanceParametersSampler=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"_allVars=",0,"! ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR),G__defined_typename("list<RooAbsPdf*>"),-1,2,"_pdfList=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR),G__defined_typename("list<RooArgSet*>"),-1,2,"_obsList=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_listlERooAbsPdfcLcLGenSpecmUcOallocatorlERooAbsPdfcLcLGenSpecmUgRsPgR),G__defined_typename("list<RooAbsPdf::GenSpec*>"),-1,2,"_gsList=",0,"!      ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdfcLcLGenSpec),-1,-1,2,"_gs1=",0,"! GenSpec #1 ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdfcLcLGenSpec),-1,-1,2,"_gs2=",0,"! GenSpec #2");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdfcLcLGenSpec),-1,-1,2,"_gs3=",0,"! GenSpec #3");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdfcLcLGenSpec),-1,-1,2,"_gs4=",0,"! GenSpec #4");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgAlwaysUseMultiGen=",0,"Use PrepareMultiGen always");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseMultiGen=",0,"Use PrepareMultiGen?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::DebuggingTestStat */
static void G__setup_memvarRooStatscLcLDebuggingTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat));
   { RooStats::DebuggingTestStat *p; p=(RooStats::DebuggingTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"fTestStatistic=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TRandom),-1,-1,4,"fRand=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::PointSetInterval */
static void G__setup_memvarRooStatscLcLPointSetInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval));
   { RooStats::PointSetInterval *p; p=(RooStats::PointSetInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fConfidenceLevel=",0,"confidence level");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fParameterPointsInInterval=",0,"either a histogram (RooDataHist) or a tree (RooDataSet)");
   }
   G__tag_memvar_reset();
}


   /* RooStats::FeldmanCousins */
static void G__setup_memvarRooStatscLcLFeldmanCousins(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins));
   { RooStats::FeldmanCousins *p; p=(RooStats::FeldmanCousins*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSize=",0,"size of the test (eg. specified rate of Type I error)");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),-1,-1,4,"fModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fData=",0,"data set ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler),-1,-1,4,"fTestStatSampler=",0,"the test statistic sampler");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fPointsToTest=",0,"points to perform the construction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fPOIToTest=",0,"value of POI points to perform the construction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt),-1,-1,4,"fConfBelt=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAdaptiveSampling=",0,"controls use of adaptive sampling algorithm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdditionalNToysFactor=",0,"give user ability to ask for more toys");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbins=",0,"number of samples per variable");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFluctuateData=",0,"tell ToyMCSampler to fluctuate number of entries in dataset");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoProfileConstruction=",0,"instead of full construction over nuisance parametrs, do profile");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSaveBeltToFile=",0,"controls use if ConfidenceBelt should be saved to a TFile");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCreateBelt=",0,"controls use if ConfidenceBelt should be saved to a TFile");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::FrequentistCalculator */
static void G__setup_memvarRooStatscLcLFrequentistCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator));
   { RooStats::FrequentistCalculator *p; p=(RooStats::FrequentistCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fConditionalMLEsNull=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fConditionalMLEsAlt=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysNull=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysAlt=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysNullTail=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysAltTail=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fFitInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fStoreFitInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::Heaviside */
static void G__setup_memvarRooStatscLcLHeaviside(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside));
   { RooStats::Heaviside *p; p=(RooStats::Heaviside*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealProxy),-1,-1,2,"x=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealProxy),-1,-1,2,"c=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HLFactory */
static void G__setup_memvarRooStatscLcLHLFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory));
   { RooStats::HLFactory *p; p=(RooStats::HLFactory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooCategory),-1,-1,4,"fComboCat=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fComboBkgPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fComboSigBkgPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,4,"fComboDataset=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fCombinationDone=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,4,"fSigBkgPdfNames=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,4,"fBkgPdfNames=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,4,"fDatasetsNames=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,4,"fLabelsNames=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fVerbose=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fInclusionLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace),-1,-1,4,"fWs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fOwnWs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HybridCalculator */
static void G__setup_memvarRooStatscLcLHybridCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator));
   { RooStats::HybridCalculator *p; p=(RooStats::HybridCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPriorNuisanceNull=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPriorNuisanceAlt=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPriorNuisanceNullExternal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPriorNuisanceAltExternal=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysNull=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysAlt=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysNullTail=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fNToysAltTail=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HybridPlot */
static void G__setup_memvarRooStatscLcLHybridPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot));
   { RooStats::HybridPlot *p; p=(RooStats::HybridPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1F),-1,-1,4,"fSb_histo=",0,"The sb Histo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1F),-1,-1,4,"fSb_histo_shaded=",0,"The sb Histo shaded");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1F),-1,-1,4,"fB_histo=",0,"The b Histo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1F),-1,-1,4,"fB_histo_shaded=",0,"The b Histo shaded");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TLine),-1,-1,4,"fData_testStat_line=",0,"The line for the data value of the test statistic");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TLegend),-1,-1,4,"fLegend=",0,"The legend of the plot");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TVirtualPad),-1,-1,4,"fPad=",0,"The pad where it has been drawn");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fVerbose=",0,"verbosity flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HybridResult */
static void G__setup_memvarRooStatscLcLHybridResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult));
   { RooStats::HybridResult *p; p=(RooStats::HybridResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fTestStat_b=",0,"vector of results for B-only toy-MC");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fTestStat_sb=",0,"vector of results for S+B toy-MC");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fTestStat_data=",0,"results (test statistics) evaluated for data");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fComputationsNulDoneFlag=",0,"flag if the fNullPValue computation have been already done or not (ie need to be refreshed)");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fComputationsAltDoneFlag=",0,"flag if the fAlternatePValue computation have been already done or not (ie need to be refreshed)");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fSumLargerValues=",0,"p-value for velues of testStat >= testStat_data (or testStat <= testStat_data)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HybridCalculatorOriginal */
static void G__setup_memvarRooStatscLcLHybridCalculatorOriginal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   { RooStats::HybridCalculatorOriginal *p; p=(RooStats::HybridCalculatorOriginal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fTestStatisticsIdx=",0,"Index of the test statistics to use");
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNToys=",0,"number of Toys MC");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fSbModel=",0,"The pdf of the signal+background model");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fBModel=",0,"The pdf of the background model");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,4,"fObservables=",0,"Collection of the observables of the model");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fNuisanceParameters=",0,"Collection of the nuisance parameters in the model");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPriorPdf=",0,"Prior PDF of the nuisance parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fData=",0,"pointer to the data sets ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fGenerateBinned=",0,"Flag to control binned generation");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUsePriorPdf=",0,"use a prior for nuisance parameters  ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fTmpDoExtended=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestInverterResult */
static void G__setup_memvarRooStatscLcLHypoTestInverterResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult));
   { RooStats::HypoTestInverterResult *p; p=(RooStats::HypoTestInverterResult*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t),-1,-2,1,G__FastAllocString(2048).Format("kLinear=%lldLL",(long long)RooStats::HypoTestInverterResult::kLinear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t),-1,-2,1,G__FastAllocString(2048).Format("kSpline=%lldLL",(long long)RooStats::HypoTestInverterResult::kSpline).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fUseCLs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fIsTwoSided=",0,"two sided scan (look for lower/upper limit) ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fInterpolateLowerLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fInterpolateUpperLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFittedLowerLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFittedUpperLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t),-1,-1,2,"fInterpolOption=",0,"interpolatation option (linear or spline)");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fLowerLimitError=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fUpperLimitError=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fCLsCleanupThreshold=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,2,"fgAsymptoticMaxSigma=",0,"max sigma value used to scan asymptotic expected p values ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fXValues=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,2,"fYObjects=",0,"list of HypoTestResult for each point");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TList),-1,-1,2,"fExpPValues=",0,"list of expected sampling distribution for each point");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestInverter */
static void G__setup_memvarRooStatscLcLHypoTestInverter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   { RooStats::HypoTestInverter *p; p=(RooStats::HypoTestInverter*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType),-1,-2,1,G__FastAllocString(2048).Format("kUndefined=%lldLL",(long long)RooStats::HypoTestInverter::kUndefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType),-1,-2,1,G__FastAllocString(2048).Format("kHybrid=%lldLL",(long long)RooStats::HypoTestInverter::kHybrid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType),-1,-2,1,G__FastAllocString(2048).Format("kFrequentist=%lldLL",(long long)RooStats::HypoTestInverter::kFrequentist).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType),-1,-2,1,G__FastAllocString(2048).Format("kAsymptotic=%lldLL",(long long)RooStats::HypoTestInverter::kAsymptotic).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-2,4,"fgNToys=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,4,"fgCLAccuracy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,4,"fgAbsAccuracy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-2,4,"fgRelAccuracy=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-2,4,"fgCloseProof=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-2,4,"fgAlgo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlETGraphErrorsgR),-1,-1,4,"fLimitPlot=",0,"! plot of limits");
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fTotalToysRun=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fMaxToys=",0,"maximum number of toys to run ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),-1,-1,4,"fCalculator0=",0,"pointer to the calculator passed in the constructor");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlERooStatscLcLHypoTestCalculatorGenericgR),-1,-1,4,"fHC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"fScannedVariable=",0,"pointer to the constrained variable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),-1,-1,4,"fResults=",0,"pointer to the result ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseCLs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fScanLog=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fVerbose=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType),-1,-1,4,"fCalcType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fNumErr=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestInverterOriginal */
static void G__setup_memvarRooStatscLcLHypoTestInverterOriginal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal));
   { RooStats::HypoTestInverterOriginal *p; p=(RooStats::HypoTestInverterOriginal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),-1,-1,4,"fCalculator0=",0,"pointer to the calculator passed in the constructor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"fScannedVariable=",0,"pointer to the constrained variable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),-1,-1,4,"fResults=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseCLs=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SamplingDistPlot */
static void G__setup_memvarRooStatscLcLSamplingDistPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot));
   { RooStats::SamplingDistPlot *p; p=(RooStats::SamplingDistPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSamplingDistr=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSampleWeights=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsWeighted=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBins=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMarkerType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fVarName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1F),-1,-1,2,"fHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TLegend),-1,-1,2,"fLegend=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooList),-1,-1,2,"fItems=",0,"holds TH1Fs only");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooList),-1,-1,2,"fOtherItems=",0,"other objects to be drawn like TLine etc.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TIterator),-1,-1,2,"fIterator=",0,"TODO remove class variable and instantiate locally as necessary");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooPlot),-1,-1,2,"fRooPlot=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogXaxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogYaxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fXMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fXMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fYMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fYMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fApplyStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fFillStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestInverterPlot */
static void G__setup_memvarRooStatscLcLHypoTestInverterPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot));
   { RooStats::HypoTestInverterPlot *p; p=(RooStats::HypoTestInverterPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),-1,-1,4,"fResults=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::HypoTestPlot */
static void G__setup_memvarRooStatscLcLHypoTestPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot));
   { RooStats::HypoTestPlot *p; p=(RooStats::HypoTestPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult),-1,-1,4,"fHypoTestResult=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::LikelihoodInterval */
static void G__setup_memvarRooStatscLcLLikelihoodInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval));
   { RooStats::LikelihoodInterval *p; p=(RooStats::LikelihoodInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fParameters=",0,"parameters of interest for this interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fBestFitParams=",0,"snapshot of the model parameters with best fit value (managed internally)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fLikelihoodRatio=",0,"likelihood ratio function used to make contours (managed internally)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fConfidenceLevel=",0,"Requested confidence level (eg. 0.95 for 95% CL)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),G__defined_typename("map<std::string,double>"),-1,4,"fLowerLimits=",0,"map with cached lower bound values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR),G__defined_typename("map<std::string,double>"),-1,4,"fUpperLimits=",0,"map with cached upper bound values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR),-1,-1,4,"fMinimizer=",0,"! transient pointer to minimizer class used to find limits and contour");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlERooFunctorgR),-1,-1,4,"fFunctor=",0,"! transient pointer to functor class used by the minimizer");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__defined_typename("auto_ptr<ROOT::Math::IMultiGenFunction>"),-1,4,"fMinFunc=",0,"! transient pointer to the minimization function ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::LikelihoodIntervalPlot */
static void G__setup_memvarRooStatscLcLLikelihoodIntervalPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot));
   { RooStats::LikelihoodIntervalPlot *p; p=(RooStats::LikelihoodIntervalPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColor=",0,"color for the contour (for 2D) or function (in 1D)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFillStyle=",0,"fill style for contours");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLineColor=",0,"line color for the interval (1D) or for other contours (2D)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdimPlot=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNPoints=",0,"number of points used to scan the PL ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMaximum=",0,"function maximum");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fYmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fYmax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPrecision=",0,"RooCurve precision");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval),-1,-1,4,"fInterval=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fParamsPlot=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TObject),-1,-1,4,"fPlotObject=",0,"plotted object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MarkovChain */
static void G__setup_memvarRooStatscLcLMarkovChain(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   { RooStats::MarkovChain *p; p=(RooStats::MarkovChain*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fDataEntry=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fChain=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,2,"fNLL=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,2,"fWeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MaxLikelihoodEstimateTestStat */
static void G__setup_memvarRooStatscLcLMaxLikelihoodEstimateTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat));
   { RooStats::MaxLikelihoodEstimateTestStat *p; p=(RooStats::MaxLikelihoodEstimateTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"fParameter=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fConditionalObs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUpperLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPrintLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProposalFunction */
static void G__setup_memvarRooStatscLcLProposalFunction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction));
   { RooStats::ProposalFunction *p; p=(RooStats::ProposalFunction*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MCMCInterval */
static void G__setup_memvarRooStatscLcLMCMCInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval));
   { RooStats::MCMCInterval *p; p=(RooStats::MCMCInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("DEFAULT_NUM_BINS=%lldLL",(long long)RooStats::MCMCInterval::DEFAULT_NUM_BINS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType),-1,-2,1,G__FastAllocString(2048).Format("kShortest=%lldLL",(long long)RooStats::MCMCInterval::kShortest).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType),-1,-2,1,G__FastAllocString(2048).Format("kTailFraction=%lldLL",(long long)RooStats::MCMCInterval::kTailFraction).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fParameters=",0,"parameters of interest for this interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain),-1,-1,2,"fChain=",0,"the markov chain");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fConfidenceLevel=",0,"Requested confidence level (eg. 0.95 for 95% CL)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataHist),-1,-1,2,"fDataHist=",0,"the binned Markov Chain data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_THnSparse),-1,-1,2,"fSparseHist=",0,"the binned Markov Chain data");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fHistConfLevel=",0,"the actual conf level determined by hist");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fHistCutoff=",0,"cutoff bin size to be in interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooNDKeysPdf),-1,-1,2,"fKeysPdf=",0,"the kernel estimation pdf");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooProduct),-1,-1,2,"fProduct=",0,"the (keysPdf * heaviside) product");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside),-1,-1,2,"fHeaviside=",0,"the Heaviside function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataHist),-1,-1,2,"fKeysDataHist=",0,"data hist representing product");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,2,"fCutoffVar=",0,"cutoff variable to use for integrating keys pdf");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fKeysConfLevel=",0,"the actual conf level determined by keys");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fKeysCutoff=",0,"cutoff keys pdf value to be in interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fFull=",0,"Value of intergral of fProduct");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLeftSideTF=",0,"left side tail-fraction for interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTFConfLevel=",0,"the actual conf level of tail-fraction interval");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fVector=",0,"vector containing the Markov chain data");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fVecWeight=",0,"sum of weights of all entries in fVector");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTFLower=",0,"lower limit of the tail-fraction interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTFUpper=",0,"upper limit of the tail-fraction interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,2,"fHist=",0,"the binned Markov Chain data");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseKeys=",0,"whether to use kernel estimation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseSparseHist=",0,"whether to use sparse hist (vs. RooDataHist)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsHistStrict=",0,"whether the specified confidence level is a");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDimension=",0,"number of variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumBurnInSteps=",0,"number of steps to discard as burn in, starting");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,2,"fAxes=",0,"array of pointers to RooRealVars representing");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEpsilon=",0,"acceptable error for Keys interval determination");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDelta=",0,"topCutoff (a) considered == bottomCutoff (b) iff");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType),-1,-1,2,"fIntervalType=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MCMCCalculator */
static void G__setup_memvarRooStatscLcLMCMCCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator));
   { RooStats::MCMCCalculator *p; p=(RooStats::MCMCCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSize=",0,"size of the test (eg. specified rate of Type I error)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fPOI=",0,"parameters of interest for interval");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fNuisParams=",0,"nuisance parameters for interval (not really used)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fChainParams=",0,"parameters to store in the chain (if not specified they are all of them )");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fConditionalObs=",0,"conditional observables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),-1,-1,2,"fPropFunc=",0,"Proposal function for MCMC integration");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPdf=",0,"pointer to common PDF (owned by the workspace)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPriorPdf=",0,"pointer to prior  PDF (owned by the workspace)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,2,"fData=",0,"pointer to the data (owned by the workspace)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumIters=",0,"number of iterations to run metropolis algorithm");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumBurnInSteps=",0,"number of iterations to discard as burn-in, starting from the first");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumBins=",0,"set the number of bins to create for each");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,2,"fAxes=",0,"which variables to put on each axis");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseKeys=",0,"whether to use kernel estimation to determine interval");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseSparseHist=",0,"whether to use sparse histogram (if using hist at all)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLeftSideTF=",0,"left side tail-fraction for interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEpsilon=",0,"acceptable error for Keys interval determination");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDelta=",0,"acceptable error for Keys cutoffs being equal");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType),-1,-1,2,"fIntervalType=",0,"type of interval to find");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MCMCIntervalPlot */
static void G__setup_memvarRooStatscLcLMCMCIntervalPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot));
   { RooStats::MCMCIntervalPlot *p; p=(RooStats::MCMCIntervalPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval),-1,-1,4,"fInterval=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,4,"fPosteriorHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooNDKeysPdf),-1,-1,4,"fPosteriorKeysPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooProduct),-1,-1,4,"fPosteriorKeysProduct=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,4,"fNLLHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,4,"fWeightHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,4,"fPosteriorHistHistCopy=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TH1),-1,-1,4,"fPosteriorHistTFCopy=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDimension=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fLineColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fShadeColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fShowBurnIn=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TGraph),-1,-1,4,"fWalk=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TGraph),-1,-1,4,"fBurnIn=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TGraph),-1,-1,4,"fFirst=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TGraph),-1,-1,4,"fParamGraph=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TGraph),-1,-1,4,"fNLLGraph=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MetropolisHastings */
static void G__setup_memvarRooStatscLcLMetropolisHastings(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings));
   { RooStats::MetropolisHastings *p; p=(RooStats::MetropolisHastings*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign),-1,-2,1,G__FastAllocString(2048).Format("kNegative=%lldLL",(long long)RooStats::MetropolisHastings::kNegative).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign),-1,-2,1,G__FastAllocString(2048).Format("kPositive=%lldLL",(long long)RooStats::MetropolisHastings::kPositive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign),-1,-2,1,G__FastAllocString(2048).Format("kSignUnset=%lldLL",(long long)RooStats::MetropolisHastings::kSignUnset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType),-1,-2,1,G__FastAllocString(2048).Format("kRegular=%lldLL",(long long)RooStats::MetropolisHastings::kRegular).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType),-1,-2,1,G__FastAllocString(2048).Format("kLog=%lldLL",(long long)RooStats::MetropolisHastings::kLog).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType),-1,-2,1,G__FastAllocString(2048).Format("kTypeUnset=%lldLL",(long long)RooStats::MetropolisHastings::kTypeUnset).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,2,"fFunction=",0,"function that will generate likelihood values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fParameters=",0,"RooRealVars that define all parameter space");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fChainParams=",0,"RooRealVars that are stored in the chain");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction),-1,-1,2,"fPropFunc=",0,"Proposal function for MCMC integration");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumIters=",0,"number of iterations to run metropolis algorithm");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumBurnInSteps=",0,"number of iterations to discard as burn-in, starting from the first");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign),-1,-1,2,"fSign=",0,"whether the likelihood is negative (like NLL) or positive");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType),-1,-1,2,"fType=",0,"whether the likelihood is on a regular, log, (or other) scale");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProfileLikelihoodTestStat */
static void G__setup_memvarRooStatscLcLProfileLikelihoodTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat));
   { RooStats::ProfileLikelihoodTestStat *p; p=(RooStats::ProfileLikelihoodTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType),-1,-2,4,"twoSided=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType),-1,-2,4,"oneSided=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType),-1,-2,4,"oneSidedDiscovery=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fNll=",0,"!");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fCachedBestFitParams=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fLastData=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType),-1,-1,4,"fLimitType=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSigned=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fDetailedOutputEnabled=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fDetailedOutputWithErrorsAndPulls=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fDetailedOutput=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fConditionalObs=",0,"conditional observables ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fVarName=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgAlwaysReuseNll=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReuseNll=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TString),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTolerance=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPrintLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::MinNLLTestStat */
static void G__setup_memvarRooStatscLcLMinNLLTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat));
   { RooStats::MinNLLTestStat *p; p=(RooStats::MinNLLTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat),-1,-1,4,"fProflts=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::NeymanConstruction */
static void G__setup_memvarRooStatscLcLNeymanConstruction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction));
   { RooStats::NeymanConstruction *p; p=(RooStats::NeymanConstruction*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSize=",0,"size of the test (eg. specified rate of Type I error)");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fData=",0,"data set ");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig),-1,-1,4,"fModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),-1,-1,4,"fTestStatSampler=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData),-1,-1,4,"fPointsToTest=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLeftSideFraction=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt),-1,-1,4,"fConfBelt=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fAdaptiveSampling=",0,"controls use of adaptive sampling algorithm");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdditionalNToysFactor=",0,"give user ability to ask for more toys");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fSaveBeltToFile=",0,"controls use if ConfidenceBelt should be saved to a TFile");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fCreateBelt=",0,"controls use if ConfidenceBelt should be saved to a TFile");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::NumberCountingPdfFactory */
static void G__setup_memvarRooStatscLcLNumberCountingPdfFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory));
   { RooStats::NumberCountingPdfFactory *p; p=(RooStats::NumberCountingPdfFactory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::NumberCountingUtils */
static void G__setup_memvarRooStatscLcLNumberCountingUtils(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingUtils));
   {
   }
   G__tag_memvar_reset();
}


   /* RooStats::NumEventsTestStat */
static void G__setup_memvarRooStatscLcLNumEventsTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat));
   { RooStats::NumEventsTestStat *p; p=(RooStats::NumEventsTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::PdfProposal */
static void G__setup_memvarRooStatscLcLPdfProposal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal));
   { RooStats::PdfProposal *p; p=(RooStats::PdfProposal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPdf=",0,"the proposal density function");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR),G__defined_typename("map<RooRealVar*,RooAbsReal*>"),-1,2,"fMap=",0,"map of values in pdf to update");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgRcLcLiterator),-1,-1,2,"fIt=",0,"pdf iterator");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fLastX=",0,"the last point we were at");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCacheSize=",0,"how many points to generate each time");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCachePosition=",0,"our position in the cached proposal data set");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fCache=",0,"the cached proposal data set");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fMaster=",0,"pointers to master variables needed for updates");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnsPdf=",0,"whether we own the proposal density function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProfileInspector */
static void G__setup_memvarRooStatscLcLProfileInspector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector));
   { RooStats::ProfileInspector *p; p=(RooStats::ProfileInspector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProfileLikelihoodCalculator */
static void G__setup_memvarRooStatscLcLProfileLikelihoodCalculator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   { RooStats::ProfileLikelihoodCalculator *p; p=(RooStats::ProfileLikelihoodCalculator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fFitResult)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooFitResult),-1,-1,1,"fFitResult=",0,"internal  result of gloabl fit ");
   }
   G__tag_memvar_reset();
}


   /* RooStats::UniformProposal */
static void G__setup_memvarRooStatscLcLUniformProposal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal));
   { RooStats::UniformProposal *p; p=(RooStats::UniformProposal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ProposalHelper */
static void G__setup_memvarRooStatscLcLProposalHelper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper));
   { RooStats::ProposalHelper *p; p=(RooStats::ProposalHelper*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fPdf=",0,"the main proposal density function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fCluesPdf=",0,"proposal dens. func. with clues for certain points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,2,"fUniformPdf=",0,"uniform proposal dens. func.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fClues=",0,"data set of clues");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TMatrixTSymlEdoublegR),G__defined_typename("TMatrixDSym"),-1,2,"fCovMatrix=",0,"covariance matrix for multi var gaussian pdf");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal),-1,-1,2,"fPdfProp=",0,"the PdfProposal we are (probably) going to return");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,2,"fVars=",0,"the RooRealVars to generate proposals for");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCacheSize=",0,"for generating proposals from PDFs");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSigmaRangeDivisor=",0,"range divisor to get sigma for each variable");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fUniFrac=",0,"what fraction of the PDF integral is uniform");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCluesFrac=",0,"what fraction of the PDF integral comes from clues");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnsPdfProp=",0,"whether we own the PdfProposal; equivalent to:");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnsPdf=",0,"whether we created (and own) the main pdf");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnsCluesPdf=",0,"whether we created (and own) the clues pdf");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnsVars=",0,"whether we own fVars");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseUpdates=",0,"whether to set updates for proposal params in PdfProposal");
   G__memvar_setup((void*)0,67,0,1,-1,G__defined_typename("Option_t"),-1,2,"fCluesOptions=",0,"option string for clues RooNDKeysPdf");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::RatioOfProfiledLikelihoodsTestStat */
static void G__setup_memvarRooStatscLcLRatioOfProfiledLikelihoodsTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat));
   { RooStats::RatioOfProfiledLikelihoodsTestStat *p; p=(RooStats::RatioOfProfiledLikelihoodsTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat),-1,-1,4,"fNullProfile=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat),-1,-1,4,"fAltProfile=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fAltPOI=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSubtractMLE=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgAlwaysReuseNll=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fDetailedOutputEnabled=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fDetailedOutput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SequentialProposal */
static void G__setup_memvarRooStatscLcLSequentialProposal(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal));
   { RooStats::SequentialProposal *p; p=(RooStats::SequentialProposal*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fDivisor=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SimpleLikelihoodRatioTestStat */
static void G__setup_memvarRooStatscLcLSimpleLikelihoodRatioTestStat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   { RooStats::SimpleLikelihoodRatioTestStat *p; p=(RooStats::SimpleLikelihoodRatioTestStat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fNullPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"fAltPdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fNullParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fAltParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fConditionalObs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFirstEval=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fDetailedOutputEnabled=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"fDetailedOutput=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fNllNull=",0,"! transient copy of the null NLL");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal),-1,-1,4,"fNllAlt=",0,"!  transient copy of the alt NLL");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgAlwaysReuseNll=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReuseNll=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::SPlot */
static void G__setup_memvarRooStatscLcLSPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   { RooStats::SPlot *p; p=(RooStats::SPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlotcLcLdA),-1,-2,2,"kOwnData=1048576LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList),-1,-1,2,"fSWeightVars=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,2,"fSData=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ToyMCImportanceSampler */
static void G__setup_memvarRooStatscLcLToyMCImportanceSampler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler));
   { RooStats::ToyMCImportanceSampler *p; p=(RooStats::ToyMCImportanceSampler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fIndexGenDensity=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fGenerateFromNull=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fApplyVeto=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fConditionalObs=",0,"set of conditional observables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR),G__defined_typename("vector<RooAbsPdf*>"),-1,2,"fNullDensities=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR),G__defined_typename("vector<const RooArgSet*>"),-1,2,"fNullSnapshots=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR),G__defined_typename("vector<RooAbsPdf*>"),-1,2,"fImportanceDensities=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR),G__defined_typename("vector<const RooArgSet*>"),-1,2,"fImportanceSnapshots=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fReuseNLL=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLtoysStrategies),-1,-1,2,"fToysStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR),G__defined_typename("vector<RooAbsReal*>"),-1,2,"fNullNLLs=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR),G__defined_typename("vector<RooAbsReal*>"),-1,2,"fImpNLLs=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ToyMCStudy */
static void G__setup_memvarRooStatscLcLToyMCStudy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy));
   { RooStats::ToyMCStudy *p; p=(RooStats::ToyMCStudy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler),-1,-1,2,"fToyMCSampler=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,2,"fParamPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::ToyMCPayload */
static void G__setup_memvarRooStatscLcLToyMCPayload(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload));
   { RooStats::ToyMCPayload *p; p=(RooStats::ToyMCPayload*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,4,"fDataSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* RooStats::UpperLimitMCSModule */
static void G__setup_memvarRooStatscLcLUpperLimitMCSModule(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule));
   { RooStats::UpperLimitMCSModule *p; p=(RooStats::UpperLimitMCSModule*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_string),-1,-1,4,"_parName=",0,"Name of Nsignal parameter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator),-1,-1,4,"_plc=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar),-1,-1,4,"_ul=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet),-1,-1,4,"_poi=",0,"parameters of interest");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet),-1,-1,4,"_data=",0,"Summary dataset to store results");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"_cl=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf),-1,-1,4,"_model=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__RooStatsLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__RooStats() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncRooStats(void) {
   /* RooStats */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStats));
   G__memfunc_setup("PValueToSignificance",2003,G__G__RooStats_109_0_1, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pvalue", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t))(&RooStats::PValueToSignificance) ), 0);
   G__memfunc_setup("SignificanceToPValue",2003,G__G__RooStats_109_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Z", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t))(&RooStats::SignificanceToPValue) ), 0);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_109_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RooArgSet' - 10 - desiredVals U 'RooArgSet' - 0 - paramsToChange", (char*)NULL, (void*) G__func2void( (void (*)(const RooArgSet*, RooArgSet*))(&RooStats::SetParameters) ), 0);
   G__memfunc_setup("RemoveConstantParameters",2508,G__G__RooStats_109_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 0 - set", (char*)NULL, (void*) G__func2void( (void (*)(RooArgSet*))(&RooStats::RemoveConstantParameters) ), 0);
   G__memfunc_setup("RemoveConstantParameters",2508,G__G__RooStats_109_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgList' - 1 - set", (char*)NULL, (void*) G__func2void( (void (*)(RooArgList&))(&RooStats::RemoveConstantParameters) ), 0);
   G__memfunc_setup("SetAllConstant",1423,G__G__RooStats_109_0_6, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooAbsCollection' - 11 - coll g - - 0 'true' constant", (char*)NULL, (void*) G__func2void( (bool (*)(const RooAbsCollection&, bool))(&RooStats::SetAllConstant) ), 0);
   G__memfunc_setup("RandomizeCollection",1973,G__G__RooStats_109_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooAbsCollection' - 1 - set g - 'Bool_t' 0 'kTRUE' randomizeConstants", (char*)NULL, (void*) G__func2void( (void (*)(RooAbsCollection&, Bool_t))(&RooStats::RandomizeCollection) ), 0);
   G__memfunc_setup("FactorizePdf",1217,G__G__RooStats_109_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'RooArgSet' - 11 - observables u 'RooAbsPdf' - 1 - pdf "
"u 'RooArgList' - 1 - obsTerms u 'RooArgList' - 1 - constraints", (char*)NULL, (void*) G__func2void( (void (*)(const RooArgSet&, RooAbsPdf&, RooArgList&, RooArgList&))(&RooStats::FactorizePdf) ), 0);
   G__memfunc_setup("FactorizePdf",1217,G__G__RooStats_109_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'RooStats::ModelConfig' - 1 - model u 'RooAbsPdf' - 1 - pdf "
"u 'RooArgList' - 1 - obsTerms u 'RooArgList' - 1 - constraints", (char*)NULL, (void*) G__func2void( (void (*)(RooStats::ModelConfig&, RooAbsPdf&, RooArgList&, RooArgList&))(&RooStats::FactorizePdf) ), 0);
   G__memfunc_setup("MakeNuisancePdf",1486,G__G__RooStats_109_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 3, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - observables "
"C - - 10 - name", (char*)NULL, (void*) G__func2void( (RooAbsPdf* (*)(RooAbsPdf&, const RooArgSet&, const char*))(&RooStats::MakeNuisancePdf) ), 0);
   G__memfunc_setup("MakeNuisancePdf",1486,G__G__RooStats_109_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::ModelConfig' - 11 - model C - - 10 - name", (char*)NULL, (void*) G__func2void( (RooAbsPdf* (*)(const RooStats::ModelConfig&, const char*))(&RooStats::MakeNuisancePdf) ), 0);
   G__memfunc_setup("MakeUnconstrainedPdf",2037,G__G__RooStats_109_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 3, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - observables "
"C - - 10 'NULL' name", (char*)NULL, (void*) G__func2void( (RooAbsPdf* (*)(RooAbsPdf&, const RooArgSet&, const char*))(&RooStats::MakeUnconstrainedPdf) ), 0);
   G__memfunc_setup("MakeUnconstrainedPdf",2037,G__G__RooStats_109_0_13, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::ModelConfig' - 11 - model C - - 10 'NULL' name", (char*)NULL, (void*) G__func2void( (RooAbsPdf* (*)(const RooStats::ModelConfig&, const char*))(&RooStats::MakeUnconstrainedPdf) ), 0);
   G__memfunc_setup("GetAsTTree",952,G__G__RooStats_109_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TTree), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 0 - name u 'TString' - 0 - desc "
"u 'RooDataSet' - 11 - data", (char*)NULL, (void*) G__func2void( (TTree* (*)(TString, TString, const RooDataSet&))(&RooStats::GetAsTTree) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestResult(void) {
   /* RooStats::HypoTestResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult));
   G__memfunc_setup("HypoTestResult",1471,G__G__RooStats_110_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestResult",1471,G__G__RooStats_110_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 1, 1, 1, 0, "u 'RooStats::HypoTestResult' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestResult",1471,G__G__RooStats_110_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - nullp "
"d - 'Double_t' 0 - altp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__RooStats_110_0_4, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 1, 1, 1, 1, 0, "u 'RooStats::HypoTestResult' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Append",600,G__G__RooStats_110_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::HypoTestResult' - 10 - other", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NullPValue",1000,G__G__RooStats_110_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlternatePValue",1517,G__G__RooStats_110_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CLb",241,G__G__RooStats_110_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CLsplusb",808,G__G__RooStats_110_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CLs",258,G__G__RooStats_110_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Significance",1219,G__G__RooStats_110_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNullDistribution",1979,G__G__RooStats_110_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAltDistribution",1857,G__G__RooStats_110_0_13, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNullDetailedOutput",2152,G__G__RooStats_110_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAltDetailedOutput",2030,G__G__RooStats_110_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitInfo",975,G__G__RooStats_110_0_16, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStatisticData",2034,G__G__RooStats_110_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllTestStatisticsData",2430,G__G__RooStats_110_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasTestStatisticData",2030,G__G__RooStats_110_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAltDistribution",1869,G__G__RooStats_110_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::SamplingDistribution' - 0 - alt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNullDistribution",1991,G__G__RooStats_110_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::SamplingDistribution' - 0 - null", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAltDetailedOutput",2042,G__G__RooStats_110_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNullDetailedOutput",2164,G__G__RooStats_110_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitInfo",987,G__G__RooStats_110_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestStatisticData",2046,G__G__RooStats_110_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - tsd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAllTestStatisticsData",2442,G__G__RooStats_110_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooArgList' - 10 - tsd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPValueIsRightTail",1981,G__G__RooStats_110_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - pr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPValueIsRightTail",1969,G__G__RooStats_110_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackgroundAsAlt",1793,G__G__RooStats_110_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackGroundIsAlt",1757,G__G__RooStats_110_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLbError",763,G__G__RooStats_110_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsplusbError",1330,G__G__RooStats_110_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsError",780,G__G__RooStats_110_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NullPValueError",1522,G__G__RooStats_110_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SignificanceError",1741,G__G__RooStats_110_0_35, 100, -1, G__defined_typename("Double_t"), 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 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdatePValue",1200,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"U 'RooStats::SamplingDistribution' - 10 - distr d - 'Double_t' 1 - pvalue "
"d - 'Double_t' 1 - perror g - 'Bool_t' 0 - pIsRightTail", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_110_0_38, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_110_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_110_0_40, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_110_0_41, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_110_0_45, 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__G__RooStats_110_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_110_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_110_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_110_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestResult::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestResult", 1597, G__G__RooStats_110_0_50, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLModelConfig(void) {
   /* RooStats::ModelConfig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig));
   G__memfunc_setup("ModelConfig",1095,G__G__RooStats_111_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 1, 1, 1, 0, "U 'RooWorkspace' - 0 '0' ws", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ModelConfig",1095,G__G__RooStats_111_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'RooWorkspace' - 0 '0' ws", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ModelConfig",1095,G__G__RooStats_111_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'RooWorkspace' - 0 '0' ws", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWS",470,G__G__RooStats_111_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooWorkspace' - 1 - ws", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWorkspace",1243,G__G__RooStats_111_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooWorkspace' - 1 - ws", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProtoData",1210,G__G__RooStats_111_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_111_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 11 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorPdf",1106,G__G__RooStats_111_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 11 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_111_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParametersOfInterest",2371,G__G__RooStats_111_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_111_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParametersOfInterest",2371,G__G__RooStats_111_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_111_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_111_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConstraintParameters",2405,G__G__RooStats_111_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConstraintParameters",2405,G__G__RooStats_111_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObservables",1444,G__G__RooStats_111_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObservables",1444,G__G__RooStats_111_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_111_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_111_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalObservables",2037,G__G__RooStats_111_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalObservables",2037,G__G__RooStats_111_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - argList", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSnapshot",1148,G__G__RooStats_111_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_111_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorPdf",1106,G__G__RooStats_111_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProtoData",1210,G__G__RooStats_111_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPdf",570,G__G__RooStats_111_0_28, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParametersOfInterest",2359,G__G__RooStats_111_0_29, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNuisanceParameters",2154,G__G__RooStats_111_0_30, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConstraintParameters",2393,G__G__RooStats_111_0_31, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPriorPdf",1094,G__G__RooStats_111_0_32, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservables",1432,G__G__RooStats_111_0_33, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConditionalObservables",2572,G__G__RooStats_111_0_34, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalObservables",2025,G__G__RooStats_111_0_35, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProtoData",1198,G__G__RooStats_111_0_36, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSnapshot",1136,G__G__RooStats_111_0_37, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadSnapshot",1232,G__G__RooStats_111_0_38, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWS",458,G__G__RooStats_111_0_39, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWorkspace",1231,G__G__RooStats_111_0_40, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GuessObsAndNuisance",1908,G__G__RooStats_111_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 11 - data", (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 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHasOnlyParameters",2046,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"u 'RooArgSet' - 11 - set C - - 10 '0' errorMsgPrefix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineSetInWS",1240,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"C - - 10 - name u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportPdfInWS",1270,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooAbsPdf' - 11 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportDataInWS",1366,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_111_0_47, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ModelConfig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_111_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ModelConfig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_111_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ModelConfig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_111_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ModelConfig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_111_0_54, 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__G__RooStats_111_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ModelConfig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_111_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ModelConfig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_111_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ModelConfig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_111_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ModelConfig::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ModelConfig", 1095, G__G__RooStats_111_0_59, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ModelConfig", 1221, G__G__RooStats_111_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_111_0_61, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 1, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestCalculator(void) {
   /* RooStats::HypoTestCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator));
   G__memfunc_setup("GetHypoTest",1120,G__G__RooStats_112_0_1, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCommonModel",1414,G__G__RooStats_112_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullModel",1208,G__G__RooStats_112_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetAlternateModel",1725,G__G__RooStats_112_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetData",678,G__G__RooStats_112_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__RooStats_112_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_112_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_112_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_112_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_112_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_112_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_112_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_112_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_112_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_112_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_112_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_112_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestCalculator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestCalculator", 1992, G__G__RooStats_112_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_112_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::HypoTestCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLTestStatistic(void) {
   /* RooStats::TestStatistic */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic));
   G__memfunc_setup("Evaluate",823,G__G__RooStats_602_0_1, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - nullPOI", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVarName",970,G__G__RooStats_602_0_2, 117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PValueIsRightTail",1681,G__G__RooStats_602_0_3, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDetailedOutput",1741,G__G__RooStats_602_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_602_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::TestStatistic::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_602_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatistic::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_602_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::TestStatistic::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_602_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::TestStatistic::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_602_0_9, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_602_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_602_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_602_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_602_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatistic::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_602_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::TestStatistic::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_602_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatistic::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_602_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::TestStatistic::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TestStatistic", 1494, G__G__RooStats_602_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_602_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 1, 1, 1, 1, 0, "u 'RooStats::TestStatistic' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSamplingDistribution(void) {
   /* RooStats::SamplingDistribution */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution));
   G__memfunc_setup("SamplingDistribution",2107,G__G__RooStats_603_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - samplingDist C - - 10 '0' varName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingDistribution",2107,G__G__RooStats_603_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - samplingDist u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - sampleWeights "
"C - - 10 '0' varName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingDistribution",2107,G__G__RooStats_603_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 '0' varName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingDistribution",2107,G__G__RooStats_603_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooDataSet' - 1 - dataSet C - - 10 '0' columnName "
"C - - 10 '0' varName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingDistribution",2107,G__G__RooStats_603_0_5, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InverseCDF",937,G__G__RooStats_603_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InverseCDFInterpolate",2096,G__G__RooStats_603_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InverseCDF",937,G__G__RooStats_603_0_8, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - pvalue d - 'Double_t' 0 - sigmaVariaton "
"d - 'Double_t' 1 - inverseVariation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_603_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::SamplingDistribution' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSize",699,G__G__RooStats_603_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamplingDistribution",2395,G__G__RooStats_603_0_11, 117, G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSampleWeights",1629,G__G__RooStats_603_0_12, 117, G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVarName",970,G__G__RooStats_603_0_13, 117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integral",822,G__G__RooStats_603_0_14, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 - low d - 'Double_t' 0 - high "
"g - 'Bool_t' 0 'kTRUE' normalize g - 'Bool_t' 0 'kTRUE' lowClosed "
"g - 'Bool_t' 0 'kFALSE' highClosed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegralAndError",1619,G__G__RooStats_603_0_15, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 8, 
"d - 'Double_t' 1 - error d - 'Double_t' 0 - low "
"d - 'Double_t' 0 - high g - 'Bool_t' 0 'kTRUE' normalize "
"g - 'Bool_t' 0 'kTRUE' lowClosed g - 'Bool_t' 0 'kFALSE' highClosed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CDF",205,G__G__RooStats_603_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortValues",1048,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_603_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SamplingDistribution::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_603_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistribution::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_603_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SamplingDistribution::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_603_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SamplingDistribution::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_603_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_603_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistribution::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_603_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingDistribution::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_603_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistribution::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_603_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingDistribution::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SamplingDistribution", 2107, G__G__RooStats_603_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 0, "u 'RooStats::SamplingDistribution' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SamplingDistribution", 2233, G__G__RooStats_603_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_603_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 1, 1, 1, 1, 0, "u 'RooStats::SamplingDistribution' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLTestStatSampler(void) {
   /* RooStats::TestStatSampler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler));
   G__memfunc_setup("GetSamplingDistribution",2395,G__G__RooStats_604_0_1, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EvaluateTestStatistic",2191,G__G__RooStats_604_0_2, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTestStatistic",1656,G__G__RooStats_604_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ConfidenceLevel",1510,G__G__RooStats_604_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Initialize",1042,G__G__RooStats_604_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'RooAbsArg' - 1 - testStatistic u 'RooArgSet' - 1 - paramsOfInterest "
"u 'RooArgSet' - 1 - nuisanceParameters", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_604_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPriorNuisance",1646,G__G__RooStats_604_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooAbsPdf' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetParametersForTestStat",2467,G__G__RooStats_604_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_604_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetObservables",1444,G__G__RooStats_604_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGlobalObservables",2037,G__G__RooStats_604_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTestSize",1127,G__G__RooStats_604_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetConfidenceLevel",1810,G__G__RooStats_604_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTestStatistic",1668,G__G__RooStats_604_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::TestStatistic' - 0 - testStatistic", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSamplingDistName",1916,G__G__RooStats_604_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__RooStats_604_0_16, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::TestStatSampler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_604_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatSampler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_604_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::TestStatSampler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_604_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::TestStatSampler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_604_0_20, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_604_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_604_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_604_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_604_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatSampler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_604_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::TestStatSampler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_604_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::TestStatSampler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_604_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::TestStatSampler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TestStatSampler", 1678, G__G__RooStats_604_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_604_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler), -1, 1, 1, 1, 1, 0, "u 'RooStats::TestStatSampler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestCalculatorGeneric(void) {
   /* RooStats::HypoTestCalculatorGeneric */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric));
   G__memfunc_setup("HypoTestCalculatorGeneric",2567,G__G__RooStats_677_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsData' - 11 - data u 'RooStats::ModelConfig' - 11 - altModel "
"u 'RooStats::ModelConfig' - 11 - nullModel U 'RooStats::TestStatSampler' - 0 '0' sampler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHypoTest",1120,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullModel",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - nullModel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetData",666,G__G__RooStats_677_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNullModel",1196,G__G__RooStats_677_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitInfo",975,G__G__RooStats_677_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternateModel",1725,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - altModel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAlternateModel",1713,G__G__RooStats_677_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLModelConfig), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestStatSampler",1840,G__G__RooStats_677_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseSameAltToys",1411,G__G__RooStats_677_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckHook",879,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreNullHook",1107,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreAltHook",985,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreHook",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostHook",823,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupSampler",1253,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAdaptiveLimits",1740,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"d - 'Double_t' 0 - obsTestStat g - 'Bool_t' 0 - forNull", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateSamplingDistribution",2918,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 4, 1, 4, 8, 
"U 'RooStats::ModelConfig' - 0 - thisModel d - - 0 - obsTestStat "
"U 'RooAbsPdf' - 0 'NULL' impDens U 'RooArgSet' - 10 'NULL' impSnapshot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_677_0_20, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestCalculatorGeneric::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_677_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculatorGeneric::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_677_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestCalculatorGeneric::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_677_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestCalculatorGeneric::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_677_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_677_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculatorGeneric::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_677_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestCalculatorGeneric::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_677_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestCalculatorGeneric::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_677_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestCalculatorGeneric::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HypoTestCalculatorGeneric", 2567, G__G__RooStats_677_0_32, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric), -1, 0, 1, 1, 1, 0, "u 'RooStats::HypoTestCalculatorGeneric' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestCalculatorGeneric", 2693, G__G__RooStats_677_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLAsymptoticCalculator(void) {
   /* RooStats::AsymptoticCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator));
   G__memfunc_setup("AsymptoticCalculator",2103,G__G__RooStats_679_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 11 - altModel "
"u 'RooStats::ModelConfig' - 11 - nullModel g - - 0 'false' nominalAsimov", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHypoTest",1120,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeAsimovData",1383,G__G__RooStats_679_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 5, 3, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 11 - model "
"u 'RooArgSet' - 11 - poiValues u 'RooArgSet' - 1 - globObs "
"U 'RooArgSet' - 10 '0' genPoiValues", (char*)NULL, (void*) G__func2void( (RooAbsData* (*)(RooAbsData&, const RooStats::ModelConfig&, const RooArgSet&, RooArgSet&, const RooArgSet*))(&RooStats::AsymptoticCalculator::MakeAsimovData) ), 0);
   G__memfunc_setup("MakeAsimovData",1383,G__G__RooStats_679_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 3, 3, 1, 0, 
"u 'RooStats::ModelConfig' - 11 - model u 'RooArgSet' - 11 - allParamValues "
"u 'RooArgSet' - 1 - globObs", (char*)NULL, (void*) G__func2void( (RooAbsData* (*)(const RooStats::ModelConfig&, const RooArgSet&, RooArgSet&))(&RooStats::AsymptoticCalculator::MakeAsimovData) ), 0);
   G__memfunc_setup("GenerateAsimovData",1812,G__G__RooStats_679_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 2, 3, 1, 0, 
"u 'RooAbsPdf' - 11 - pdf u 'RooArgSet' - 11 - observables", (char*)NULL, (void*) G__func2void( (RooAbsData* (*)(const RooAbsPdf&, const RooArgSet&))(&RooStats::AsymptoticCalculator::GenerateAsimovData) ), 0);
   G__memfunc_setup("GetExpectedPValues",1810,G__G__RooStats_679_0_6, 100, -1, -1, 0, 5, 3, 1, 0, 
"d - - 0 - pnull d - - 0 - palt "
"d - - 0 - nsigma g - - 0 - usecls "
"g - - 0 'true' oneSided", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double, bool, bool))(&RooStats::AsymptoticCalculator::GetExpectedPValues) ), 0);
   G__memfunc_setup("SetOneSided",1079,G__G__RooStats_679_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTwoSided",1103,G__G__RooStats_679_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOneSidedDiscovery",2031,G__G__RooStats_679_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTwoSided",991,G__G__RooStats_679_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOneSidedDiscovery",1919,G__G__RooStats_679_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetQTilde",879,G__G__RooStats_679_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitPoi",1273,G__G__RooStats_679_0_13, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMuHat",767,G__G__RooStats_679_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParams",1589,G__G__RooStats_679_0_15, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrintLevel",1329,G__G__RooStats_679_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "i - - 0 - level", (char*)NULL, (void*) G__func2void( (void (*)(int))(&RooStats::AsymptoticCalculator::SetPrintLevel) ), 0);
   G__memfunc_setup("GenerateAsimovDataSinglePdf",2704,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 4, 3, 2, 0, 
"u 'RooAbsPdf' - 11 - pdf u 'RooArgSet' - 11 - obs "
"u 'RooRealVar' - 11 - weightVar U 'RooCategory' - 0 '0' channelCat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateCountingAsimovData",2651,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 4, 3, 2, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - obs "
"u 'RooRealVar' - 11 - weightVar U 'RooCategory' - 0 '0' channelCat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBins",787,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 3, 2, 0, 
"u 'RooAbsPdf' - 11 - pdf u 'RooArgList' - 11 - obs "
"u 'RooAbsData' - 1 - data i - - 1 - index "
"d - - 1 - binVolume i - - 1 - ibin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateNLL",1053,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 4, 3, 2, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooAbsData' - 1 - data "
"U 'RooArgSet' - 10 - condObs U 'RooArgSet' - 10 '0' poiSet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetObsToExpected",1605,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 2, 3, 2, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - obs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetObsToExpected",1605,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 2, 3, 2, 0, 
"u 'RooProdPdf' - 1 - prod u 'RooArgSet' - 11 - obs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_679_0_23, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::AsymptoticCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_679_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AsymptoticCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_679_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::AsymptoticCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_679_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::AsymptoticCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_679_0_30, 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__G__RooStats_679_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AsymptoticCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_679_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::AsymptoticCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_679_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AsymptoticCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_679_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::AsymptoticCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("AsymptoticCalculator", 2103, G__G__RooStats_679_0_35, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::AsymptoticCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~AsymptoticCalculator", 2229, G__G__RooStats_679_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLConfInterval(void) {
   /* RooStats::ConfInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval));
   G__memfunc_setup("operator=",937,G__G__RooStats_684_0_2, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval), -1, 1, 1, 1, 1, 0, "u 'RooStats::ConfInterval' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInInterval",1208,G__G__RooStats_684_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetConfidenceLevel",1810,G__G__RooStats_684_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ConfidenceLevel",1510,G__G__RooStats_684_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetParameters",1332,G__G__RooStats_684_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckParameters",1522,G__G__RooStats_684_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__RooStats_684_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ConfInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_684_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_684_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ConfInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_684_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ConfInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_684_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__G__RooStats_684_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_684_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ConfInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_684_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_684_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ConfInterval::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~ConfInterval", 1353, G__G__RooStats_684_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLIntervalCalculator(void) {
   /* RooStats::IntervalCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator));
   G__memfunc_setup("GetInterval",1125,G__G__RooStats_685_0_1, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Size",411,G__G__RooStats_685_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ConfidenceLevel",1510,G__G__RooStats_685_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetData",678,G__G__RooStats_685_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetModel",797,G__G__RooStats_685_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTestSize",1127,G__G__RooStats_685_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetConfidenceLevel",1810,G__G__RooStats_685_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__RooStats_685_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::IntervalCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_685_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::IntervalCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_685_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::IntervalCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_685_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::IntervalCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_685_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_685_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_685_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_685_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__G__RooStats_685_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::IntervalCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_685_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::IntervalCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_685_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::IntervalCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_685_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::IntervalCalculator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~IntervalCalculator", 1997, G__G__RooStats_685_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_685_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::IntervalCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSimpleInterval(void) {
   /* RooStats::SimpleInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval));
   G__memfunc_setup("SimpleInterval",1455,G__G__RooStats_686_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimpleInterval",1455,G__G__RooStats_686_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::SimpleInterval' - 11 - other C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__RooStats_686_0_3, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 1, 1, 1, 1, 0, "u 'RooStats::SimpleInterval' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimpleInterval",1455,G__G__RooStats_686_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name u 'RooRealVar' - 11 - var "
"d - 'Double_t' 0 - lower d - 'Double_t' 0 - upper "
"d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInInterval",1208,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimit",1032,G__G__RooStats_686_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimit",1035,G__G__RooStats_686_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckParameters",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_686_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SimpleInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_686_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_686_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SimpleInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_686_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SimpleInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_686_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__G__RooStats_686_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_686_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SimpleInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_686_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_686_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SimpleInterval::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SimpleInterval", 1455, G__G__RooStats_686_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 0, 1, 1, 1, 0, "u 'RooStats::SimpleInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SimpleInterval", 1581, G__G__RooStats_686_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLBayesianCalculator(void) {
   /* RooStats::BayesianCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator));
   G__memfunc_setup("BayesianCalculator",1846,G__G__RooStats_687_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BayesianCalculator",1846,G__G__RooStats_687_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator), -1, 0, 5, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooAbsPdf' - 1 - pdf "
"u 'RooArgSet' - 11 - POI u 'RooAbsPdf' - 1 - priorPdf "
"U 'RooArgSet' - 10 '0' nuisanceParameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BayesianCalculator",1846,G__G__RooStats_687_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 1 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosteriorPlot",1670,G__G__RooStats_687_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooPlot), -1, 0, 2, 1, 1, 8, 
"g - - 0 'false' norm d - - 0 '0.01' precision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosteriorPdf",1537,G__G__RooStats_687_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosteriorFunction",2093,G__G__RooStats_687_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_687_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_687_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorPdf",1106,G__G__RooStats_687_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_687_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeftSideTailFraction",2300,G__G__RooStats_687_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - leftSideFraction", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShortestInterval",1997,G__G__RooStats_687_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBrfPrecision",1522,G__G__RooStats_687_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - precision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScanOfPosterior",1837,G__G__RooStats_687_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 '100' nbin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumIters",1123,G__G__RooStats_687_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numIters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntegrationType",1874,G__G__RooStats_687_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMode",677,G__G__RooStats_687_0_24, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceNuisancePdf",1599,G__G__RooStats_687_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearAll",768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApproximatePosterior",2129,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeIntervalFromApproxPosterior",3575,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"d - - 0 - c1 d - - 0 - c2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeIntervalFromCdf",2243,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"d - - 0 - c1 d - - 0 - c2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeIntervalUsingRooFit",2683,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"d - - 0 - c1 d - - 0 - c2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeShortestInterval",2430,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_687_0_32, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::BayesianCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_687_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BayesianCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_687_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::BayesianCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_687_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::BayesianCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_687_0_39, 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__G__RooStats_687_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BayesianCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_687_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::BayesianCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_687_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BayesianCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_687_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::BayesianCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("BayesianCalculator", 1846, G__G__RooStats_687_0_44, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::BayesianCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BayesianCalculator", 1972, G__G__RooStats_687_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_687_0_46, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::BayesianCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLBernsteinCorrection(void) {
   /* RooStats::BernsteinCorrection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection));
   G__memfunc_setup("BernsteinCorrection",1986,G__G__RooStats_702_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection), -1, 0, 1, 1, 1, 0, "d - - 0 '0.05' tolerance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportCorrectedPdf",1840,G__G__RooStats_702_0_2, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'RooWorkspace' - 0 - - C - - 10 - - "
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxCorrection",1642,G__G__RooStats_702_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - maxCorr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateQSamplingDist",1908,G__G__RooStats_702_0_4, 121, -1, -1, 0, 8, 1, 1, 0, 
"U 'RooWorkspace' - 0 - wks C - - 10 - nominalName "
"C - - 10 - varName C - - 10 - dataName "
"U 'TH1F' - 0 - - U 'TH1F' - 0 - - "
"i - 'Int_t' 0 - degree i - 'Int_t' 0 '500' nToys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_702_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::BernsteinCorrection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_702_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BernsteinCorrection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_702_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::BernsteinCorrection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_702_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::BernsteinCorrection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_702_0_9, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_702_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_702_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_702_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_702_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BernsteinCorrection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_702_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::BernsteinCorrection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_702_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::BernsteinCorrection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_702_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::BernsteinCorrection::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("BernsteinCorrection", 1986, G__G__RooStats_702_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection), -1, 0, 1, 1, 1, 0, "u 'RooStats::BernsteinCorrection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BernsteinCorrection", 2112, G__G__RooStats_702_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_702_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection), -1, 1, 1, 1, 1, 0, "u 'RooStats::BernsteinCorrection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLCombinedCalculator(void) {
   /* RooStats::CombinedCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator));
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetHypoTest",1120,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullModel",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternateModel",1725,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_703_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_703_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_703_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullParameters",1755,G__G__RooStats_703_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternateParameters",2272,G__G__RooStats_703_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_703_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPdf",570,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetData",666,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_703_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::CombinedCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_703_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::CombinedCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_703_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::CombinedCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_703_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::CombinedCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_703_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_703_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::CombinedCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_703_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::CombinedCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_703_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::CombinedCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_703_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::CombinedCalculator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~CombinedCalculator", 1961, G__G__RooStats_703_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_703_0_35, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::CombinedCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSamplingSummaryLookup(void) {
   /* RooStats::SamplingSummaryLookup */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup));
   G__memfunc_setup("SamplingSummaryLookup",2211,G__G__RooStats_704_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_704_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - cl d - 'Double_t' 0 - leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLookupIndex",1426,G__G__RooStats_704_0_3, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - cl d - 'Double_t' 0 - leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfidenceLevel",1798,G__G__RooStats_704_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftSideTailFraction",2288,G__G__RooStats_704_0_5, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_704_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SamplingSummaryLookup::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_704_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummaryLookup::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_704_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SamplingSummaryLookup::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_704_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SamplingSummaryLookup::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_704_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_704_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummaryLookup::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_704_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingSummaryLookup::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_704_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummaryLookup::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_704_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingSummaryLookup::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SamplingSummaryLookup", 2211, G__G__RooStats_704_0_18, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup), -1, 0, 1, 1, 1, 0, "u 'RooStats::SamplingSummaryLookup' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SamplingSummaryLookup", 2337, G__G__RooStats_704_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_704_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup), -1, 1, 1, 1, 1, 0, "u 'RooStats::SamplingSummaryLookup' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLAcceptanceRegion(void) {
   /* RooStats::AcceptanceRegion */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion));
   G__memfunc_setup("AcceptanceRegion",1611,G__G__RooStats_713_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptanceRegion",1611,G__G__RooStats_713_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - lu d - 'Double_t' 0 - ll "
"d - 'Double_t' 0 - ul", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLookupIndex",1426,G__G__RooStats_713_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerLimit",1320,G__G__RooStats_713_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperLimit",1323,G__G__RooStats_713_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_713_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::AcceptanceRegion::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_713_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AcceptanceRegion::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_713_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::AcceptanceRegion::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_713_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::AcceptanceRegion::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_713_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_713_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AcceptanceRegion::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_713_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::AcceptanceRegion::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_713_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::AcceptanceRegion::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_713_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::AcceptanceRegion::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("AcceptanceRegion", 1611, G__G__RooStats_713_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 0, 1, 1, 1, 0, "u 'RooStats::AcceptanceRegion' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~AcceptanceRegion", 1737, G__G__RooStats_713_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_713_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 1, 1, 1, 1, 0, "u 'RooStats::AcceptanceRegion' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSamplingSummary(void) {
   /* RooStats::SamplingSummary */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary));
   G__memfunc_setup("SamplingSummary",1577,G__G__RooStats_714_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingSummary",1577,G__G__RooStats_714_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary), -1, 0, 1, 1, 1, 0, "u 'RooStats::AcceptanceRegion' - 1 - ar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameterPointIndex",2243,G__G__RooStats_714_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamplingDistribution",2395,G__G__RooStats_714_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAcceptanceRegion",1899,G__G__RooStats_714_0_5, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 '0' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAcceptanceRegion",1876,G__G__RooStats_714_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::AcceptanceRegion' - 1 - ar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_714_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SamplingSummary::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_714_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummary::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_714_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SamplingSummary::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_714_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SamplingSummary::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_714_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_714_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummary::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_714_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingSummary::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_714_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingSummary::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_714_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingSummary::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SamplingSummary", 1577, G__G__RooStats_714_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary), -1, 0, 1, 1, 1, 0, "u 'RooStats::SamplingSummary' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SamplingSummary", 1703, G__G__RooStats_714_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_714_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingSummary), -1, 1, 1, 1, 1, 0, "u 'RooStats::SamplingSummary' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLConfidenceBelt(void) {
   /* RooStats::ConfidenceBelt */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt));
   G__memfunc_setup("ConfidenceBelt",1397,G__G__RooStats_722_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfidenceBelt",1397,G__G__RooStats_722_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfidenceBelt",1397,G__G__RooStats_722_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfidenceBelt",1397,G__G__RooStats_722_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfidenceBelt",1397,G__G__RooStats_722_0_5, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAcceptanceRegion",1876,G__G__RooStats_722_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'RooArgSet' - 1 - - u 'RooStats::AcceptanceRegion' - 0 - region "
"d - 'Double_t' 0 '-1.' cl d - 'Double_t' 0 '-1.' leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAcceptanceRegion",1876,G__G__RooStats_722_0_7, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'RooArgSet' - 1 - point i - 'Int_t' 0 - dataSetIndex "
"d - 'Double_t' 0 - lower d - 'Double_t' 0 - upper "
"d - 'Double_t' 0 '-1.' cl d - 'Double_t' 0 '-1.' leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAcceptanceRegion",1899,G__G__RooStats_722_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion), -1, 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - - d - 'Double_t' 0 '-1.' cl "
"d - 'Double_t' 0 '-1.' leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAcceptanceRegionMin",2191,G__G__RooStats_722_0_9, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - - d - 'Double_t' 0 '-1.' cl "
"d - 'Double_t' 0 '-1.' leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAcceptanceRegionMax",2193,G__G__RooStats_722_0_10, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - - d - 'Double_t' 0 '-1.' cl "
"d - 'Double_t' 0 '-1.' leftside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConfidenceLevels",1625,G__G__RooStats_722_0_11, 117, G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameters",1332,G__G__RooStats_722_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckParameters",1522,G__G__RooStats_722_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_722_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ConfidenceBelt::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_722_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfidenceBelt::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_722_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ConfidenceBelt::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_722_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ConfidenceBelt::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_722_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_722_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfidenceBelt::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_722_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ConfidenceBelt::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_722_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ConfidenceBelt::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_722_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ConfidenceBelt::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ConfidenceBelt", 1397, G__G__RooStats_722_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 1, 1, 1, 0, "u 'RooStats::ConfidenceBelt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ConfidenceBelt", 1523, G__G__RooStats_722_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_722_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 1, 1, 1, 1, 0, "u 'RooStats::ConfidenceBelt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLDebuggingSampler(void) {
   /* RooStats::DebuggingSampler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler));
   G__memfunc_setup("GetSamplingDistribution",2395,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateTestStatistic",2191,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - - u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestStatistic",1656,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'RooAbsArg' - 1 - - u 'RooArgSet' - 1 - - "
"u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_728_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParametersForTestStat",2467,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalObservables",2037,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestStatistic",1668,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::TestStatistic' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_728_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::DebuggingSampler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_728_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingSampler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_728_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::DebuggingSampler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_728_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::DebuggingSampler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_728_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__G__RooStats_728_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingSampler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_728_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DebuggingSampler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_728_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingSampler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_728_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DebuggingSampler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~DebuggingSampler", 1758, G__G__RooStats_728_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_728_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler), -1, 1, 1, 1, 1, 0, "u 'RooStats::DebuggingSampler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProofConfig(void) {
   /* RooStats::ProofConfig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProofConfig));
   G__memfunc_setup("ProofConfig",1116,G__G__RooStats_735_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProofConfig), -1, 0, 4, 1, 1, 0, 
"u 'RooWorkspace' - 1 - w i - 'Int_t' 0 '8' nExperiments "
"C - - 10 '\"\"' host g - 'Bool_t' 0 'kFALSE' showGui", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseProof",1020,G__G__RooStats_735_0_2, 121, -1, -1, 0, 1, 3, 1, 0, "C - 'Option_t' 10 '\"s\"' option", (char*)NULL, (void*) G__func2void( (void (*)(Option_t*))(&RooStats::ProofConfig::CloseProof) ), 0);
   G__memfunc_setup("GetWorkspace",1231,G__G__RooStats_735_0_3, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHost",702,G__G__RooStats_735_0_4, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNExperiments",1538,G__G__RooStats_735_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowGui",998,G__G__RooStats_735_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_735_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProofConfig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_735_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProofConfig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_735_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProofConfig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_735_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProofConfig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_735_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_735_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_735_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_735_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_735_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProofConfig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_735_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProofConfig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_735_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProofConfig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_735_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProofConfig::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProofConfig", 1116, G__G__RooStats_735_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProofConfig), -1, 0, 1, 1, 1, 0, "u 'RooStats::ProofConfig' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProofConfig", 1242, G__G__RooStats_735_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLDetailedOutputAggregator(void) {
   /* RooStats::DetailedOutputAggregator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator));
   G__memfunc_setup("GetAsArgSet",1050,G__G__RooStats_736_0_1, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 3, 3, 1, 0, 
"U 'RooFitResult' - 0 - result u 'TString' - 0 '\"\"' prefix "
"g - - 0 'false' withErrorsAndPulls", (char*)NULL, (void*) G__func2void( (RooArgSet* (*)(RooFitResult*, TString, bool))(&RooStats::DetailedOutputAggregator::GetAsArgSet) ), 0);
   G__memfunc_setup("DetailedOutputAggregator",2480,G__G__RooStats_736_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AppendArgSet",1182,G__G__RooStats_736_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RooAbsCollection' - 10 - aset u 'TString' - 0 '\"\"' prefix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAsArgList",1162,G__G__RooStats_736_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CommitSet",917,G__G__RooStats_736_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAsDataSet",1146,G__G__RooStats_736_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 - name u 'TString' - 0 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_736_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::DetailedOutputAggregator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_736_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DetailedOutputAggregator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_736_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::DetailedOutputAggregator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_736_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::DetailedOutputAggregator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_736_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_736_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_736_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_736_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_736_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DetailedOutputAggregator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_736_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DetailedOutputAggregator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_736_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DetailedOutputAggregator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_736_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DetailedOutputAggregator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("DetailedOutputAggregator", 2480, G__G__RooStats_736_0_19, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator), -1, 0, 1, 1, 1, 0, "u 'RooStats::DetailedOutputAggregator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~DetailedOutputAggregator", 2606, G__G__RooStats_736_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_736_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator), -1, 1, 1, 1, 1, 0, "u 'RooStats::DetailedOutputAggregator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLToyMCSampler(void) {
   /* RooStats::ToyMCSampler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler));
   G__memfunc_setup("ToyMCSampler",1184,G__G__RooStats_738_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToyMCSampler",1184,G__G__RooStats_738_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::TestStatistic' - 1 - ts i - 'Int_t' 0 - ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlwaysUseMultiGen",2031,G__G__RooStats_738_0_3, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&RooStats::ToyMCSampler::SetAlwaysUseMultiGen) ), 0);
   G__memfunc_setup("SetUseMultiGen",1406,G__G__RooStats_738_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamplingDistribution",2395,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramPoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSamplingDistributions",2510,G__G__RooStats_738_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramPoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSamplingDistributionsSingleWorker",3754,G__G__RooStats_738_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramPoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AppendSamplingDistribution",2707,G__G__RooStats_738_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - allParameters U 'RooStats::SamplingDistribution' - 0 - last "
"i - 'Int_t' 0 - additionalMC", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTestStatistic",1633,G__G__RooStats_738_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::TestStatistic' - 0 'NULL' t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_738_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 2, 1, 1, 8, 
"u 'RooArgSet' - 1 - paramPoint u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_738_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 1, 1, 1, 8, "u 'RooArgSet' - 1 - paramPoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_738_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 3, 1, 1, 8, 
"u 'RooArgSet' - 1 - paramPoint d - - 1 - weight "
"u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_738_0_13, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 2, 1, 1, 8, 
"u 'RooArgSet' - 1 - paramPoint d - - 1 - weight", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateGlobalObservables",2548,G__G__RooStats_738_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateTestStatistic",2191,G__G__RooStats_738_0_15, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - nullPOI "
"i - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateTestStatistic",2191,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - nullPOI", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateAllTestStatistics",2587,G__G__RooStats_738_0_17, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 11 - poi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestStatistic",1656,G__G__RooStats_738_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestStatistic",1656,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'RooAbsArg' - 1 - - u 'RooArgSet' - 1 - - "
"u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNToys",797,G__G__RooStats_738_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNToys",809,G__G__RooStats_738_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - ntoy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNEventsPerToy",1618,G__G__RooStats_738_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 10 - nevents", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParametersForTestStat",2467,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - nullpoi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorNuisance",1646,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'RooAbsPdf' - 0 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - np", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObservables",1444,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalObservables",2037,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestStatistic",1668,G__G__RooStats_738_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RooStats::TestStatistic' - 0 - testStatistic h - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestStatistic",1668,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::TestStatistic' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetExpectedNuisancePar",2231,G__G__RooStats_738_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAsimovNuisancePar",2036,G__G__RooStats_738_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckConfig",1076,G__G__RooStats_738_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGenerateBinned",1703,G__G__RooStats_738_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' binned", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGenerateBinnedTag",1987,G__G__RooStats_738_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' binnedTag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGenerateAutoBinned",2112,G__G__RooStats_738_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autoBinned", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSamplingDistName",1916,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSamplingDistName",1904,G__G__RooStats_738_0_42, 117, G__get_linked_tagnum(&G__G__RooStatsLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxToys",1025,G__G__RooStats_738_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToysLeftTail",1520,G__G__RooStats_738_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - toys d - 'Double_t' 0 - threshold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToysRightTail",1635,G__G__RooStats_738_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - toys d - 'Double_t' 0 - threshold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToysBothTails",1637,G__G__RooStats_738_0_46, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - toys d - 'Double_t' 0 - low_threshold "
"d - 'Double_t' 0 - high_threshold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProofConfig",1416,G__G__RooStats_738_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::ProofConfig' - 0 'NULL' pc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProtoData",1210,G__G__RooStats_738_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 10 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateAllTestStatistics",2587,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 3, 1, 2, 1, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 11 - poi "
"u 'RooStats::DetailedOutputAggregator' - 1 - detOutAgg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Generate",811,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 4, 1, 2, 8, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 1 - observables "
"U 'RooDataSet' - 10 'NULL' protoData i - - 0 '0' forceEvents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearCache",955,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_738_0_52, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ToyMCSampler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_738_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCSampler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_738_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ToyMCSampler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_738_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ToyMCSampler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_738_0_59, 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__G__RooStats_738_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCSampler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_738_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCSampler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_738_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCSampler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_738_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCSampler::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ToyMCSampler", 1184, G__G__RooStats_738_0_64, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCSampler), -1, 0, 1, 1, 1, 0, "u 'RooStats::ToyMCSampler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ToyMCSampler", 1310, G__G__RooStats_738_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLDebuggingTestStat(void) {
   /* RooStats::DebuggingTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat));
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - - u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_754_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::DebuggingTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_754_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_754_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::DebuggingTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_754_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::DebuggingTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_754_0_10, 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__G__RooStats_754_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_754_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DebuggingTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_754_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::DebuggingTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_754_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::DebuggingTestStat::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~DebuggingTestStat", 1862, G__G__RooStats_754_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_754_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat), -1, 1, 1, 1, 1, 0, "u 'RooStats::DebuggingTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLPointSetInterval(void) {
   /* RooStats::PointSetInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval));
   G__memfunc_setup("PointSetInterval",1659,G__G__RooStats_755_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PointSetInterval",1659,G__G__RooStats_755_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInInterval",1208,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameterPoints",1854,G__G__RooStats_755_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckParameters",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimit",1032,G__G__RooStats_755_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimit",1035,G__G__RooStats_755_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_755_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::PointSetInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_755_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PointSetInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_755_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::PointSetInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_755_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::PointSetInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_755_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__G__RooStats_755_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PointSetInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_755_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::PointSetInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_755_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PointSetInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_755_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::PointSetInterval::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PointSetInterval", 1659, G__G__RooStats_755_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 0, 1, 1, 1, 0, "u 'RooStats::PointSetInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PointSetInterval", 1785, G__G__RooStats_755_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_755_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 1, 1, 1, 1, 0, "u 'RooStats::PointSetInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLFeldmanCousins(void) {
   /* RooStats::FeldmanCousins */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins));
   G__memfunc_setup("FeldmanCousins",1435,G__G__RooStats_756_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 1 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_756_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_756_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_756_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameterPointsToTest",2477,G__G__RooStats_756_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - pointsToTest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPOIPointsToTest",1780,G__G__RooStats_756_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - poiToTest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsToScan",1509,G__G__RooStats_756_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfidenceBelt",1685,G__G__RooStats_756_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseAdaptiveSampling",1942,G__G__RooStats_756_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdditionalNToysFactor",2133,G__G__RooStats_756_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - fact", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBins",774,G__G__RooStats_756_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FluctuateNumDataEntries",2353,G__G__RooStats_756_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveBeltToFile",1369,G__G__RooStats_756_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateConfBelt",1377,G__G__RooStats_756_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStatSampler",1840,G__G__RooStats_756_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateParameterPoints",2162,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateTestStatSampler",2148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_756_0_25, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::FeldmanCousins::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_756_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FeldmanCousins::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_756_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::FeldmanCousins::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_756_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::FeldmanCousins::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_756_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__G__RooStats_756_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FeldmanCousins::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_756_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::FeldmanCousins::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_756_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FeldmanCousins::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_756_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::FeldmanCousins::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("FeldmanCousins", 1435, G__G__RooStats_756_0_37, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins), -1, 0, 1, 1, 1, 0, "u 'RooStats::FeldmanCousins' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FeldmanCousins", 1561, G__G__RooStats_756_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLFrequentistCalculator(void) {
   /* RooStats::FrequentistCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator));
   G__memfunc_setup("FrequentistCalculator",2212,G__G__RooStats_764_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsData' - 11 - data u 'RooStats::ModelConfig' - 11 - altModel "
"u 'RooStats::ModelConfig' - 11 - nullModel U 'RooStats::TestStatSampler' - 0 '0' sampler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToys",731,G__G__RooStats_764_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - toysNull i - - 0 - toysAlt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNToysInTails",1501,G__G__RooStats_764_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - toysNull i - - 0 - toysAlt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConditionalMLEsNull",2188,G__G__RooStats_764_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 10 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConditionalMLEsAlt",2066,G__G__RooStats_764_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 10 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StoreFitInfo",1212,G__G__RooStats_764_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitInfo",975,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreNullHook",1107,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - parameterPoint d - - 0 - obsTestStat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreAltHook",985,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - parameterPoint d - - 0 - obsTestStat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreHook",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostHook",823,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_764_0_12, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::FrequentistCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_764_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FrequentistCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_764_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::FrequentistCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_764_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::FrequentistCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_764_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__G__RooStats_764_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FrequentistCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_764_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::FrequentistCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_764_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::FrequentistCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_764_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::FrequentistCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("FrequentistCalculator", 2212, G__G__RooStats_764_0_24, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::FrequentistCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FrequentistCalculator", 2338, G__G__RooStats_764_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHeaviside(void) {
   /* RooStats::Heaviside */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside));
   G__memfunc_setup("Heaviside",914,G__G__RooStats_767_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Heaviside",914,G__G__RooStats_767_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooAbsReal' - 1 - _x u 'RooAbsReal' - 1 - _c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Heaviside",914,G__G__RooStats_767_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHeaviside), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::Heaviside' - 11 - other C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clone",529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - newname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("evaluate",855,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_767_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::Heaviside::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_767_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::Heaviside::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_767_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::Heaviside::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_767_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::Heaviside::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_767_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_767_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::Heaviside::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_767_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::Heaviside::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_767_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::Heaviside::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_767_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::Heaviside::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Heaviside", 1040, G__G__RooStats_767_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHLFactory(void) {
   /* RooStats::HLFactory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory));
   G__memfunc_setup("HLFactory",876,G__G__RooStats_769_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '0' fileName "
"g - - 0 'false' isVerbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HLFactory",876,G__G__RooStats_769_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'RooWorkspace' - 0 - externalWs "
"g - - 0 'false' isVerbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HLFactory",876,G__G__RooStats_769_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHLFactory), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddChannel",962,G__G__RooStats_769_0_4, 105, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - label C - - 10 - SigBkgPdfName "
"C - - 10 '0' BkgPdfName C - - 10 '0' datasetName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCfg",678,G__G__RooStats_769_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", "Dump the factory content as configuration file", (void*) NULL, 0);
   G__memfunc_setup("GetTotSigBkgPdf",1448,G__G__RooStats_769_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 0, "", "Get the Signal and Background combined model", (void*) NULL, 0);
   G__memfunc_setup("GetTotBkgPdf",1157,G__G__RooStats_769_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 0, "", "Get the Background combined model", (void*) NULL, 0);
   G__memfunc_setup("GetTotDataSet",1277,G__G__RooStats_769_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 0, "", "Get the combined dataset", (void*) NULL, 0);
   G__memfunc_setup("GetTotCategory",1429,G__G__RooStats_769_0_9, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooCategory), -1, 0, 0, 1, 1, 0, "", "Get the category", (void*) NULL, 0);
   G__memfunc_setup("GetWs",490,G__G__RooStats_769_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooWorkspace), -1, 0, 0, 1, 1, 0, "", "Expose the internal Workspace", (void*) NULL, 0);
   G__memfunc_setup("ProcessCard",1113,G__G__RooStats_769_0_11, 105, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fCreateCategory",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fNamesListsConsistent",2195,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fReadFile",866,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 4, 0, 
"C - - 10 - fileName g - - 0 'false' is_included", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("fParseLine",1001,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 1 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_769_0_16, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HLFactory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_769_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HLFactory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_769_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HLFactory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_769_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HLFactory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_769_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_769_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HLFactory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_769_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HLFactory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_769_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HLFactory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_769_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HLFactory::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HLFactory", 1002, G__G__RooStats_769_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHybridCalculator(void) {
   /* RooStats::HybridCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator));
   G__memfunc_setup("HybridCalculator",1644,G__G__RooStats_770_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsData' - 11 - data u 'RooStats::ModelConfig' - 11 - altModel "
"u 'RooStats::ModelConfig' - 11 - nullModel U 'RooStats::TestStatSampler' - 0 '0' sampler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForcePriorNuisanceNull",2252,G__G__RooStats_770_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - priorNuisance", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForcePriorNuisanceAlt",2130,G__G__RooStats_770_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - priorNuisance", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullModel",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - nullModel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternateModel",1725,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - altModel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetToys",731,G__G__RooStats_770_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - toysNull i - - 0 - toysAlt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNToysInTails",1501,G__G__RooStats_770_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 - toysNull i - - 0 - toysAlt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckHook",879,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreNullHook",1107,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - - d - - 0 - obsTestStat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreAltHook",985,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 2, 1, 2, 8, 
"U 'RooArgSet' - 0 - - d - - 0 - obsTestStat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_770_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HybridCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_770_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_770_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HybridCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_770_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HybridCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_770_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__G__RooStats_770_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_770_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_770_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_770_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HybridCalculator", 1644, G__G__RooStats_770_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::HybridCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HybridCalculator", 1770, G__G__RooStats_770_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHybridPlot(void) {
   /* RooStats::HybridPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot));
   G__memfunc_setup("HybridPlot",1025,G__G__RooStats_771_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - sb_values u 'vector<double,allocator<double> >' 'vector<double>' 11 - b_values "
"d - - 0 - testStat_data i - - 0 - n_bins "
"g - - 0 'true' verbosity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DumpToFile",985,G__G__RooStats_771_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - RootFileName C - - 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBmean",771,G__G__RooStats_771_0_4, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBrms",692,G__G__RooStats_771_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBhisto",905,G__G__RooStats_771_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TH1F), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCenter",963,G__G__RooStats_771_0_7, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '1' n_sigmas g - - 0 'false' display", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBIntExtremes",1498,G__G__RooStats_771_0_8, 68, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - frac", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSBmean",854,G__G__RooStats_771_0_9, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSBCenter",1046,G__G__RooStats_771_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '1' n_sigmas g - - 0 'false' display", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSBrms",775,G__G__RooStats_771_0_11, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSBIntExtremes",1581,G__G__RooStats_771_0_12, 68, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - frac", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSBhisto",988,G__G__RooStats_771_0_13, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TH1F), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCanvas",892,G__G__RooStats_771_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TVirtualPad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpToImage",1084,G__G__RooStats_771_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistoCenter",1416,G__G__RooStats_771_0_16, 100, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - histo d - - 0 '1' n_rms "
"g - - 0 'false' display_result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistoPvals",1325,G__G__RooStats_771_0_17, 68, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - histo d - - 0 - percentage", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedian",878,G__G__RooStats_771_0_18, 100, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - histo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_771_0_19, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HybridPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_771_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_771_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HybridPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_771_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HybridPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_771_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_771_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_771_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_771_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_771_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridPlot::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HybridPlot", 1025, G__G__RooStats_771_0_31, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::HybridPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HybridPlot", 1151, G__G__RooStats_771_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_771_0_33, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot), -1, 1, 1, 1, 1, 0, "u 'RooStats::HybridPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHybridResult(void) {
   /* RooStats::HybridResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult));
   G__memfunc_setup("HybridResult",1249,G__G__RooStats_772_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HybridResult",1249,G__G__RooStats_772_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name u 'vector<double,allocator<double> >' 'vector<double>' 11 - testStat_sb_vals "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - testStat_b_vals g - - 0 'true' sumLargerValues", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataTestStatistics",2161,G__G__RooStats_772_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - testStat_data_val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_772_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::HybridResult' - 0 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlot",703,G__G__RooStats_772_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridPlot), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - - 0 - n_bins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintMore",928,G__G__RooStats_772_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStat_sb",1424,G__G__RooStats_772_0_7, 117, G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStat_b",1309,G__G__RooStats_772_0_8, 117, G__get_linked_tagnum(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStat_data",1621,G__G__RooStats_772_0_9, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NullPValue",1000,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlternatePValue",1517,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CLbError",763,G__G__RooStats_772_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsplusbError",1330,G__G__RooStats_772_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsError",780,G__G__RooStats_772_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_772_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HybridResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_772_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_772_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HybridResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_772_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HybridResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_772_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__G__RooStats_772_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_772_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_772_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_772_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HybridResult", 1249, G__G__RooStats_772_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 1, 1, 1, 0, "u 'RooStats::HybridResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HybridResult", 1375, G__G__RooStats_772_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHybridCalculatorOriginal(void) {
   /* RooStats::HybridCalculatorOriginal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal));
   G__memfunc_setup("HybridCalculatorOriginal",2465,G__G__RooStats_773_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HybridCalculatorOriginal",2465,G__G__RooStats_773_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal), -1, 0, 8, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - sb_model u 'RooAbsPdf' - 1 - b_model "
"u 'RooArgList' - 1 - observables U 'RooArgSet' - 10 '0' nuisance_parameters "
"U 'RooAbsPdf' - 0 '0' prior_pdf g - - 0 'false' GenerateBinned "
"i - - 0 '1' testStatistics i - - 0 '1000' ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HybridCalculatorOriginal",2465,G__G__RooStats_773_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal), -1, 0, 8, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooAbsPdf' - 1 - sb_model "
"u 'RooAbsPdf' - 1 - b_model U 'RooArgSet' - 10 '0' nuisance_parameters "
"U 'RooAbsPdf' - 0 '0' prior_pdf g - - 0 'false' GenerateBinned "
"i - - 0 '1' testStatistics i - - 0 '1000' ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HybridCalculatorOriginal",2465,G__G__RooStats_773_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal), -1, 0, 6, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 11 - sb_model "
"u 'RooStats::ModelConfig' - 11 - b_model g - - 0 'false' GenerateBinned "
"i - - 0 '1' testStatistics i - - 0 '1000' ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHypoTest",1120,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullModel",1208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternateModel",1725,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCommonPdf",1199,G__G__RooStats_773_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullPdf",993,G__G__RooStats_773_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlternatePdf",1510,G__G__RooStats_773_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNullParameters",1755,G__G__RooStats_773_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", "not needed", (void*) NULL, 1);
   G__memfunc_setup("SetAlternateParameters",2272,G__G__RooStats_773_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", "not needed", (void*) NULL, 1);
   G__memfunc_setup("SetNuisancePdf",1404,G__G__RooStats_773_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - prior_pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_773_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumberOfToys",1529,G__G__RooStats_773_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumberOfToys",1517,G__G__RooStats_773_0_17, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseNuisance",1123,G__G__RooStats_773_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGenerateBinned",1703,G__G__RooStats_773_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestStatistic",1668,G__G__RooStats_773_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Calculate",910,G__G__RooStats_773_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 3, 1, 1, 8, 
"u 'TH1' - 1 - data h - - 0 - nToys "
"g - - 0 - usePriors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Calculate",910,G__G__RooStats_773_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 3, 1, 1, 8, 
"u 'RooAbsData' - 1 - data h - - 0 - nToys "
"g - - 0 - usePriors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Calculate",910,G__G__RooStats_773_0_23, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridResult), -1, 0, 2, 1, 1, 8, 
"h - - 0 - nToys g - - 0 - usePriors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintMore",928,G__G__RooStats_773_0_24, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PatchSetExtended",1613,G__G__RooStats_773_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", "patch to test with RooPoisson (or other non-extended models)", (void*) NULL, 0);
   G__memfunc_setup("RunToys",740,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - bVals u 'vector<double,allocator<double> >' 'vector<double>' 1 - sbVals "
"h - - 0 - nToys g - - 0 - usePriors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCheckInputs",1300,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_773_0_28, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HybridCalculatorOriginal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_773_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculatorOriginal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_773_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HybridCalculatorOriginal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_773_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HybridCalculatorOriginal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_773_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__G__RooStats_773_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculatorOriginal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_773_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridCalculatorOriginal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_773_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HybridCalculatorOriginal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_773_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HybridCalculatorOriginal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HybridCalculatorOriginal", 2465, G__G__RooStats_773_0_40, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal), -1, 0, 1, 1, 1, 0, "u 'RooStats::HybridCalculatorOriginal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HybridCalculatorOriginal", 2591, G__G__RooStats_773_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestInverterResult(void) {
   /* RooStats::HypoTestInverterResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult));
   G__memfunc_setup("HypoTestInverterResult",2318,G__G__RooStats_777_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverterResult",2318,G__G__RooStats_777_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name u 'RooRealVar' - 11 - scannedVariable "
"d - - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverterResult",2318,G__G__RooStats_777_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::HypoTestInverterResult' - 11 - other C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__RooStats_777_0_4, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 1, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterResult' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExclusionCleanup",1666,G__G__RooStats_777_0_5, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_777_0_6, 103, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterResult' - 11 - otherResult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_777_0_7, 103, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x u 'RooStats::HypoTestResult' - 11 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXValue",885,G__G__RooStats_777_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYValue",886,G__G__RooStats_777_0_9, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYError",899,G__G__RooStats_777_0_10, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsplusb",808,G__G__RooStats_777_0_11, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLb",241,G__G__RooStats_777_0_12, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLs",258,G__G__RooStats_777_0_13, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsplusbError",1330,G__G__RooStats_777_0_14, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLbError",763,G__G__RooStats_777_0_15, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CLsError",780,G__G__RooStats_777_0_16, 100, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResult",927,G__G__RooStats_777_0_17, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastYValue",1290,G__G__RooStats_777_0_18, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastXValue",1289,G__G__RooStats_777_0_19, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastYError",1303,G__G__RooStats_777_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastResult",1331,G__G__RooStats_777_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArraySize",922,G__G__RooStats_777_0_22, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindIndex",889,G__G__RooStats_777_0_23, 105, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - xvalue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestSize",1127,G__G__RooStats_777_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCLsCleanupThreshold",2211,G__G__RooStats_777_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - th", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCLs",559,G__G__RooStats_777_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOneSided",967,G__G__RooStats_777_0_28, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTwoSided",991,G__G__RooStats_777_0_29, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerLimit",1032,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimit",1035,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitEstimatedError",2482,G__G__RooStats_777_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimitEstimatedError",2485,G__G__RooStats_777_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedPValueDist",2099,G__G__RooStats_777_0_34, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackgroundTestStatDist",2544,G__G__RooStats_777_0_35, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSignalAndBackgroundTestStatDist",3425,G__G__RooStats_777_0_36, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNullTestStatDist",1931,G__G__RooStats_777_0_37, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAltTestStatDist",1809,G__G__RooStats_777_0_38, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerLimitDistribution",2600,G__G__RooStats_777_0_39, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperLimitDistribution",2603,G__G__RooStats_777_0_40, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedLowerLimit",2138,G__G__RooStats_777_0_41, 100, -1, -1, 0, 2, 1, 1, 8, 
"d - - 0 '0' nsig C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedUpperLimit",2141,G__G__RooStats_777_0_42, 100, -1, -1, 0, 2, 1, 1, 8, 
"d - - 0 '0' nsig C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindInterpolatedLimit",2155,G__G__RooStats_777_0_43, 100, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - target g - - 0 'false' lowSearch "
"d - - 0 '1' xmin d - - 0 '0' xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInterpolationOption",2317,G__G__RooStats_777_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RooStats::HypoTestInverterResult::InterpolOption_t' - 0 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterpolationOption",2305,G__G__RooStats_777_0_45, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateEstimatedError",2360,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 4, 1, 4, 0, 
"d - - 0 - target g - - 0 'true' lower "
"d - - 0 '1' xmin d - - 0 '0' xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindClosestPointIndex",2144,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 3, 1, 4, 0, 
"d - - 0 - target i - - 0 '0' mode "
"d - - 0 '0' xtarget", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimitDistribution",2079,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 1, 1, 4, 8, "g - - 0 - lower", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExpectedLimit",1617,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 3, 1, 4, 8, 
"d - - 0 - nsig g - - 0 - lower "
"C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraphX",874,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 5, 1, 4, 8, 
"u 'TGraph' - 11 - g d - - 0 - y0 "
"g - - 0 - lowSearch d - - 1 - xmin "
"d - - 1 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraphX",874,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 3, 1, 4, 8, 
"u 'TGraph' - 11 - g d - - 0 - y0 "
"g - - 0 'true' lowSearch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_777_0_52, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestInverterResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_777_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_777_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestInverterResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_777_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestInverterResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_777_0_59, 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__G__RooStats_777_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_777_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_777_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_777_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterResult::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestInverterResult", 2444, G__G__RooStats_777_0_64, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestInverter(void) {
   /* RooStats::HypoTestInverter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter));
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::HypoTestCalculatorGeneric' - 1 - hc U 'RooRealVar' - 0 '0' scannedVariable "
"d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::HybridCalculator' - 1 - hc U 'RooRealVar' - 0 '0' scannedVariable "
"d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::FrequentistCalculator' - 1 - hc U 'RooRealVar' - 0 - scannedVariable "
"d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_5, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::AsymptoticCalculator' - 1 - hc U 'RooRealVar' - 0 - scannedVariable "
"d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverter",1679,G__G__RooStats_783_0_6, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 6, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 1 - sb "
"u 'RooStats::ModelConfig' - 1 - b U 'RooRealVar' - 0 '0' scannedVariable "
"i 'RooStats::HypoTestInverter::ECalculatorType' - 0 'kFrequentist' type d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,G__G__RooStats_783_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixedScan",1185,G__G__RooStats_783_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - - 0 - nBins d - - 0 '1' xMin "
"d - - 0 '-1' xMax g - - 0 'false' scanLog", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoScan",1098,G__G__RooStats_783_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunFixedScan",1194,G__G__RooStats_783_0_11, 103, -1, -1, 0, 4, 1, 1, 8, 
"i - - 0 - nBins d - - 0 - xMin "
"d - - 0 - xMax g - - 0 'false' scanLog", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunOnePoint",1121,G__G__RooStats_783_0_12, 103, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - thisX g - - 0 'false' adaptive "
"d - - 0 '-1' clTarget", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunLimit",820,G__G__RooStats_783_0_13, 103, -1, -1, 0, 5, 1, 1, 8, 
"d - - 1 - limit d - - 1 - limitErr "
"d - - 0 '0' absTol d - - 0 '0' relTol "
"D - - 10 '0' hint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCLs",559,G__G__RooStats_783_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", "not needed ", (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHypoTestCalculator",2154,G__G__RooStats_783_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerLimitDistribution",2600,G__G__RooStats_783_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 2, 1, 1, 0, 
"g - - 0 'false' rebuild i - - 0 '100' nToys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperLimitDistribution",2603,G__G__RooStats_783_0_23, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 2, 1, 1, 0, 
"g - - 0 'false' rebuild i - - 0 '100' nToys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RebuildDistributions",2106,G__G__RooStats_783_0_24, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution), -1, 0, 5, 1, 1, 0, 
"g - - 0 'true' isUpper i - - 0 '100' nToys "
"U 'TList' - 0 '0' clsDist U 'TList' - 0 '0' clsbDist "
"U 'TList' - 0 '0' clbDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStatistic",1656,G__G__RooStats_783_0_25, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatistic), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestStatistic",1668,G__G__RooStats_783_0_26, 103, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::TestStatistic' - 1 - stat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVerbose",1026,G__G__RooStats_783_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 '1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaximumToys",1465,G__G__RooStats_783_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumErr",901,G__G__RooStats_783_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCloseProof",1320,G__G__RooStats_783_0_30, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&RooStats::HypoTestInverter::SetCloseProof) ), 0);
   G__memfunc_setup("HypoTestInverter",1679,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 0, 1, 1, 2, 0, "u 'RooStats::HypoTestInverter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter), -1, 1, 1, 1, 2, 0, "u 'RooStats::HypoTestInverter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateResults",1350,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 3, 1, 2, 8, 
"u 'RooStats::HypoTestCalculatorGeneric' - 1 - hc g - - 0 - adaptive "
"d - - 0 - clsTarget", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableToScan",1678,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 1, 3, 2, 0, "u 'RooStats::HypoTestCalculatorGeneric' - 11 - hc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckInputModels",1618,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"u 'RooStats::HypoTestCalculatorGeneric' - 11 - hc u 'RooRealVar' - 11 - scanVar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_783_0_37, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestInverter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_783_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_783_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestInverter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_783_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestInverter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_783_0_44, 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__G__RooStats_783_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_783_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_783_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_783_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestInverter", 1805, G__G__RooStats_783_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestInverterOriginal(void) {
   /* RooStats::HypoTestInverterOriginal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal));
   G__memfunc_setup("HypoTestInverterOriginal",2500,G__G__RooStats_787_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverterOriginal",2500,G__G__RooStats_787_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::HypoTestCalculator' - 1 - myhc0 u 'RooRealVar' - 1 - scannedVariable "
"d - - 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RunAutoScan",1107,G__G__RooStats_787_0_4, 103, -1, -1, 0, 5, 1, 1, 0, 
"d - - 0 - xMin d - - 0 - xMax "
"d - - 0 - target d - - 0 '0.005' epsilon "
"h - - 0 '0' numAlgorithm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunFixedScan",1194,G__G__RooStats_787_0_5, 103, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - nBins d - - 0 - xMin "
"d - - 0 - xMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunOnePoint",1121,G__G__RooStats_787_0_6, 103, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - thisX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCLs",559,G__G__RooStats_787_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - -", "not needed", (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - -", "not needed ", (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateResults",1350,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_787_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestInverterOriginal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_787_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterOriginal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_787_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestInverterOriginal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_787_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestInverterOriginal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_787_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__G__RooStats_787_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterOriginal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_787_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterOriginal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_787_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterOriginal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_787_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterOriginal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HypoTestInverterOriginal", 2500, G__G__RooStats_787_0_27, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal), -1, 0, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterOriginal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestInverterOriginal", 2626, G__G__RooStats_787_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_787_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal), -1, 1, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterOriginal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSamplingDistPlot(void) {
   /* RooStats::SamplingDistPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot));
   G__memfunc_setup("SamplingDistPlot",1646,G__G__RooStats_789_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplingDistPlot",1646,G__G__RooStats_789_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nbins d - 'Double_t' 0 - min "
"d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSamplingDistribution",2372,G__G__RooStats_789_0_3, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'RooStats::SamplingDistribution' - 10 - samplingDist C - 'Option_t' 10 '\"NORMALIZE HIST\"' drawOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSamplingDistributionShaded",2957,G__G__RooStats_789_0_4, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"U 'RooStats::SamplingDistribution' - 10 - samplingDist d - 'Double_t' 0 - minShaded "
"d - 'Double_t' 0 - maxShaded C - 'Option_t' 10 '\"NORMALIZE HIST\"' drawOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLine",657,G__G__RooStats_789_0_5, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"C - - 10 'NULL' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTH1",470,G__G__RooStats_789_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h C - 'Option_t' 10 '\"\"' drawOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTF1",468,G__G__RooStats_789_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TF1' - 0 - f C - - 10 'NULL' title "
"C - 'Option_t' 10 '\"SAME\"' drawOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLegend",891,G__G__RooStats_789_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TLegend' - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ApplyDefaultStyle",1756,G__G__RooStats_789_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineColor",1203,G__G__RooStats_789_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineWidth",1204,G__G__RooStats_789_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Width_t' 0 - lwidth U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineStyle",1221,G__G__RooStats_789_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 - style U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerColor",1421,G__G__RooStats_789_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerStyle",1439,G__G__RooStats_789_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 - style U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerSize",1321,G__G__RooStats_789_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Size_t' 0 - size U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RebinDistribution",1776,G__G__RooStats_789_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rebinFactor U 'RooStats::SamplingDistribution' - 10 '0' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxisTitle",1219,G__G__RooStats_789_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - varName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetApplyStyle",1347,G__G__RooStats_789_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTH1F",563,G__G__RooStats_789_0_20, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TH1F), -1, 0, 1, 1, 1, 0, "U 'RooStats::SamplingDistribution' - 10 'NULL' samplDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogXaxis",1115,G__G__RooStats_789_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - lx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogYaxis",1116,G__G__RooStats_789_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXRange",881,G__G__RooStats_789_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - mi d - - 0 - ma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYRange",882,G__G__RooStats_789_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - mi d - - 0 - ma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpToFile",985,G__G__RooStats_789_0_25, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - RootFileName C - 'Option_t' 10 '\"\"' option "
"C - - 10 '\"\"' ftitle i - 'Int_t' 0 '1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSampleWeights",1641,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'RooStats::SamplingDistribution' - 10 - samplingDist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("addObject",896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' drawOptions", "for TH1Fs only", (void*) NULL, 0);
   G__memfunc_setup("addOtherObject",1410,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' drawOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbsoluteInterval",1956,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"d - 'Double_t' 1 - theMin d - 'Double_t' 1 - theMax "
"d - 'Double_t' 1 - theYMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_789_0_30, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SamplingDistPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_789_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_789_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SamplingDistPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_789_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SamplingDistPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_789_0_37, 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__G__RooStats_789_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_789_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingDistPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_789_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SamplingDistPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_789_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SamplingDistPlot::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~SamplingDistPlot", 1772, G__G__RooStats_789_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestInverterPlot(void) {
   /* RooStats::HypoTestInverterPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot));
   G__memfunc_setup("HypoTestInverterPlot",2094,G__G__RooStats_790_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot), -1, 0, 1, 1, 1, 0, "U 'RooStats::HypoTestInverterResult' - 0 - results", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestInverterPlot",2094,G__G__RooStats_790_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'RooStats::HypoTestInverterResult' - 0 - results", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePlot",797,G__G__RooStats_790_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TGraphErrors), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeExpectedPlot",1615,G__G__RooStats_790_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TMultiGraph), -1, 0, 2, 1, 1, 0, 
"d - - 0 '1' sig1 d - - 0 '2' sig2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTestStatPlot",1625,G__G__RooStats_790_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot), -1, 0, 3, 1, 1, 0, 
"i - - 0 - index i - - 0 '0' type "
"i - - 0 '100' nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_790_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestInverterPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_790_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_790_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestInverterPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_790_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestInverterPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_790_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_790_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_790_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_790_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestInverterPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_790_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestInverterPlot::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("HypoTestInverterPlot", 2094, G__G__RooStats_790_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestInverterPlot", 2220, G__G__RooStats_790_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_790_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot), -1, 1, 1, 1, 1, 0, "u 'RooStats::HypoTestInverterPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLHypoTestPlot(void) {
   /* RooStats::HypoTestPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot));
   G__memfunc_setup("HypoTestPlot",1247,G__G__RooStats_805_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot), -1, 0, 0, 1, 1, 0, "", "needed for IO ", (void*) NULL, 0);
   G__memfunc_setup("HypoTestPlot",1247,G__G__RooStats_805_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot), -1, 0, 3, 1, 1, 0, 
"u 'RooStats::HypoTestResult' - 1 - result i - 'Int_t' 0 '100' bins "
"C - 'Option_t' 10 '\"NORMALIZE HIST\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HypoTestPlot",1247,G__G__RooStats_805_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot), -1, 0, 5, 1, 1, 0, 
"u 'RooStats::HypoTestResult' - 1 - result i - 'Int_t' 0 - bins "
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
"C - 'Option_t' 10 '\"NORMALIZE HIST\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyResult",1157,G__G__RooStats_805_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooStats::HypoTestResult' - 1 - result C - 'Option_t' 10 '\"NORMALIZE HIST\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyDefaultStyle",1756,G__G__RooStats_805_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_805_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::HypoTestPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_805_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_805_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::HypoTestPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_805_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::HypoTestPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_805_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_805_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_805_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_805_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::HypoTestPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_805_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::HypoTestPlot::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~HypoTestPlot", 1373, G__G__RooStats_805_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLLikelihoodInterval(void) {
   /* RooStats::LikelihoodInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval));
   G__memfunc_setup("LikelihoodInterval",1865,G__G__RooStats_807_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LikelihoodInterval",1865,G__G__RooStats_807_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'RooAbsReal' - 0 - - "
"U 'RooArgSet' - 10 - - U 'RooArgSet' - 0 '0' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInInterval",1208,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckParameters",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimit",1032,G__G__RooStats_807_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 11 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerLimit",1032,G__G__RooStats_807_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooRealVar' - 11 - param g - - 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimit",1035,G__G__RooStats_807_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 11 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimit",1035,G__G__RooStats_807_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooRealVar' - 11 - param g - - 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindLimits",1011,G__G__RooStats_807_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'RooRealVar' - 11 - param d - - 1 - lower "
"d - - 1 - upper", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContourPoints",1671,G__G__RooStats_807_0_13, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"u 'RooRealVar' - 11 - paramX u 'RooRealVar' - 11 - paramY "
"D - 'Double_t' 0 - x D - 'Double_t' 0 - y "
"i - 'Int_t' 0 '30' npoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLikelihoodRatio",1827,G__G__RooStats_807_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsReal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__G__RooStats_807_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetLimits",1141,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMinimizer",1544,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_807_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::LikelihoodInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_807_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_807_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::LikelihoodInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_807_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::LikelihoodInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_807_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_807_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_807_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::LikelihoodInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_807_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_807_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::LikelihoodInterval::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("LikelihoodInterval", 1865, G__G__RooStats_807_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval), -1, 0, 1, 1, 1, 0, "u 'RooStats::LikelihoodInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LikelihoodInterval", 1991, G__G__RooStats_807_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_807_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval), -1, 1, 1, 1, 1, 0, "u 'RooStats::LikelihoodInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLLikelihoodIntervalPlot(void) {
   /* RooStats::LikelihoodIntervalPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot));
   G__memfunc_setup("LikelihoodIntervalPlot",2280,G__G__RooStats_823_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LikelihoodIntervalPlot",2280,G__G__RooStats_823_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot), -1, 0, 1, 1, 1, 0, "U 'RooStats::LikelihoodInterval' - 0 - theInterval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlottedObject",1619,G__G__RooStats_823_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLikelihoodInterval",2165,G__G__RooStats_823_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooStats::LikelihoodInterval' - 0 - theInterval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlotParameters",1759,G__G__RooStats_823_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 10 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRange",793,G__G__RooStats_823_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x1 d - - 0 - x2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRange",793,G__G__RooStats_823_0_7, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - x1 d - - 0 - y1 "
"d - - 0 - x2 d - - 0 - y2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__G__RooStats_823_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - eps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetContourColor",1557,G__G__RooStats_823_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 10 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineColor",1203,G__G__RooStats_823_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 10 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaximum",1034,G__G__RooStats_823_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 10 - theMaximum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNPoints",1015,G__G__RooStats_823_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - np", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_823_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::LikelihoodIntervalPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_823_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodIntervalPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_823_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::LikelihoodIntervalPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_823_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::LikelihoodIntervalPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_823_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_823_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodIntervalPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_823_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::LikelihoodIntervalPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_823_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::LikelihoodIntervalPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_823_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::LikelihoodIntervalPlot::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("LikelihoodIntervalPlot", 2280, G__G__RooStats_823_0_26, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::LikelihoodIntervalPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~LikelihoodIntervalPlot", 2406, G__G__RooStats_823_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_823_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot), -1, 1, 1, 1, 1, 0, "u 'RooStats::LikelihoodIntervalPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMarkovChain(void) {
   /* RooStats::MarkovChain */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain));
   G__memfunc_setup("MarkovChain",1107,G__G__RooStats_868_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarkovChain",1107,G__G__RooStats_868_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarkovChain",1107,G__G__RooStats_868_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooArgSet' - 1 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__RooStats_868_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - entry d - 'Double_t' 0 - nllValue "
"d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFast",663,G__G__RooStats_868_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'RooArgSet' - 1 - entry d - 'Double_t' 0 - nllValue "
"d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWithBurnIn",1267,G__G__RooStats_868_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooStats::MarkovChain' - 1 - otherChain i - 'Int_t' 0 '0' burnIn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__RooStats_868_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooStats::MarkovChain' - 1 - otherChain d - 'Double_t' 0 '0.0' discardEntries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_868_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__RooStats_868_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,G__G__RooStats_868_0_10, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,G__G__RooStats_868_0_11, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Weight",616,G__G__RooStats_868_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Weight",616,G__G__RooStats_868_0_13, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NLL",230,G__G__RooStats_868_0_14, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NLL",230,G__G__RooStats_868_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsDataSet",1146,G__G__RooStats_868_0_16, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 8, "U 'RooArgSet' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsDataSet",1146,G__G__RooStats_868_0_17, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 8, 1, 1, 8, 
"u 'RooCmdArg' - 11 - arg1 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg2 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg3 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg4 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg5 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg6 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg7 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg8", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsConstDataSet",1665,G__G__RooStats_868_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsDataHist",1254,G__G__RooStats_868_0_19, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataHist), -1, 0, 1, 1, 1, 8, "U 'RooArgSet' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsDataHist",1254,G__G__RooStats_868_0_20, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataHist), -1, 0, 8, 1, 1, 8, 
"u 'RooCmdArg' - 11 - arg1 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg2 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg3 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg4 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg5 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg6 "
"u 'RooCmdArg' - 11 'RooCmdArg::none()' arg7 u 'RooCmdArg' - 11 'RooCmdArg::none()' arg8", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsSparseHist",1498,G__G__RooStats_868_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_THnSparse), -1, 0, 1, 1, 1, 8, "U 'RooAbsCollection' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAsSparseHist",1498,G__G__RooStats_868_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_THnSparse), -1, 0, 1, 1, 1, 8, "u 'RooAbsCollection' - 1 - whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNLLVar",815,G__G__RooStats_868_0_23, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWeightVar",1201,G__G__RooStats_868_0_24, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_868_0_25, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MarkovChain::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_868_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MarkovChain::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_868_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MarkovChain::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_868_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MarkovChain::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_868_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__G__RooStats_868_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MarkovChain::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_868_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MarkovChain::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_868_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MarkovChain::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_868_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MarkovChain::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MarkovChain", 1107, G__G__RooStats_868_0_37, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 1, 1, 1, 0, "u 'RooStats::MarkovChain' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MarkovChain", 1233, G__G__RooStats_868_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_868_0_39, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 1, 1, 1, 1, 0, "u 'RooStats::MarkovChain' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMaxLikelihoodEstimateTestStat(void) {
   /* RooStats::MaxLikelihoodEstimateTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat));
   G__memfunc_setup("MaxLikelihoodEstimateTestStat",2978,G__G__RooStats_921_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaxLikelihoodEstimateTestStat",2978,G__G__RooStats_921_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooRealVar' - 1 - parameter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PValueIsRightTail",1681,G__G__RooStats_921_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - isright", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PValueIsRightTail",1681,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_921_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_921_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MaxLikelihoodEstimateTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_921_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MaxLikelihoodEstimateTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_921_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MaxLikelihoodEstimateTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_921_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MaxLikelihoodEstimateTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_921_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__G__RooStats_921_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MaxLikelihoodEstimateTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_921_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MaxLikelihoodEstimateTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_921_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MaxLikelihoodEstimateTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_921_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MaxLikelihoodEstimateTestStat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MaxLikelihoodEstimateTestStat", 2978, G__G__RooStats_921_0_20, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::MaxLikelihoodEstimateTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MaxLikelihoodEstimateTestStat", 3104, G__G__RooStats_921_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_921_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat), -1, 1, 1, 1, 1, 0, "u 'RooStats::MaxLikelihoodEstimateTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProposalFunction(void) {
   /* RooStats::ProposalFunction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction));
   G__memfunc_setup("Propose",744,G__G__RooStats_922_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - xPrime u 'RooArgSet' - 1 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsSymmetric",1145,G__G__RooStats_922_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetProposalDensity",1872,G__G__RooStats_922_0_4, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckParameters",1522,G__G__RooStats_922_0_5, 103, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_922_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProposalFunction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_922_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalFunction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_922_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProposalFunction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_922_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProposalFunction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_922_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_922_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalFunction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_922_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProposalFunction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_922_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalFunction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_922_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProposalFunction::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~ProposalFunction", 1812, G__G__RooStats_922_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_922_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction), -1, 1, 1, 1, 1, 0, "u 'RooStats::ProposalFunction' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMCMCInterval(void) {
   /* RooStats::MCMCInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval));
   G__memfunc_setup("MCMCInterval",1125,G__G__RooStats_925_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval), -1, 0, 1, 5, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCMCInterval",1125,G__G__RooStats_925_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name u 'RooArgSet' - 11 - parameters "
"u 'RooStats::MarkovChain' - 1 - chain", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInInterval",1208,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameters",1332,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistCutoff",1311,G__G__RooStats_925_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKeysPdfCutoff",1597,G__G__RooStats_925_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActualConfidenceLevel",2400,G__G__RooStats_925_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHistStrict",1341,G__G__RooStats_925_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isHistStrict", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckParameters",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'RooArgSet' - 11 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_925_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChain",783,G__G__RooStats_925_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::MarkovChain' - 1 - chain", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxes",701,G__G__RooStats_925_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgList' - 1 - axes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxes",689,G__G__RooStats_925_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimit",1032,G__G__RooStats_925_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitTailFraction",2248,G__G__RooStats_925_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitShortest",1892,G__G__RooStats_925_0_18, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitByKeys",1631,G__G__RooStats_925_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitByHist",1627,G__G__RooStats_925_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitBySparseHist",2249,G__G__RooStats_925_0_21, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LowerLimitByDataHist",2005,G__G__RooStats_925_0_22, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimit",1035,G__G__RooStats_925_0_23, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitTailFraction",2251,G__G__RooStats_925_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitShortest",1895,G__G__RooStats_925_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitByKeys",1634,G__G__RooStats_925_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitByHist",1630,G__G__RooStats_925_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitBySparseHist",2252,G__G__RooStats_925_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpperLimitByDataHist",2008,G__G__RooStats_925_0_29, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKeysMax",994,G__G__RooStats_925_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumBurnInSteps",1721,G__G__RooStats_925_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numBurnInSteps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUseKeys",1013,G__G__RooStats_925_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - useKeys", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUseSparseHist",1631,G__G__RooStats_925_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - useSparseHist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUseKeys",1001,G__G__RooStats_925_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumBurnInSteps",1709,G__G__RooStats_925_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPosteriorHist",1663,G__G__RooStats_925_0_36, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPosteriorKeysPdf",1949,G__G__RooStats_925_0_37, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooNDKeysPdf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPosteriorKeysProduct",2404,G__G__RooStats_925_0_38, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooProduct), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDimension",1222,G__G__RooStats_925_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChain",771,G__G__RooStats_925_0_40, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainAsDataSet",1629,G__G__RooStats_925_0_41, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainAsConstDataSet",2148,G__G__RooStats_925_0_42, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainAsDataHist",1737,G__G__RooStats_925_0_43, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataHist), -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainAsSparseHist",1981,G__G__RooStats_925_0_44, 85, G__get_linked_tagnum(&G__G__RooStatsLN_THnSparse), -1, 0, 1, 1, 1, 0, "U 'RooArgSet' - 0 'NULL' whichVars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNLLVar",815,G__G__RooStats_925_0_45, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWeightVar",1201,G__G__RooStats_925_0_46, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEpsilon",1030,G__G__RooStats_925_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntervalType",1555,G__G__RooStats_925_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RooStats::MCMCInterval::IntervalType' - 0 - intervalType", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntervalType",1543,G__G__RooStats_925_0_49, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeftSideTailFraction",2300,G__G__RooStats_925_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDelta",790,G__G__RooStats_925_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AcceptableConfLevel",1890,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - confLevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WithinDeltaFraction",1939,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DetermineInterval",1762,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineShortestInterval",2622,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineTailFractionInterval",2978,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineByHist",1520,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineBySparseHist",2142,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineByDataHist",1898,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DetermineByKeys",1524,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHist",1004,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateSparseHist",1626,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateDataHist",1382,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateKeysPdf",1290,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateKeysDataHist",1794,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateVector",1223,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'RooRealVar' - 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcConfLevel",1265,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 0 - cutoff d - 'Double_t' 0 - full", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_925_0_68, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MCMCInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_925_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_925_0_70, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MCMCInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_925_0_71, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MCMCInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_925_0_75, 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__G__RooStats_925_0_76, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_925_0_77, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_925_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_925_0_79, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCInterval::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCMCInterval", 1125, G__G__RooStats_925_0_80, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval), -1, 0, 1, 1, 1, 0, "u 'RooStats::MCMCInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCMCInterval", 1251, G__G__RooStats_925_0_81, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_925_0_82, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval), -1, 1, 1, 1, 1, 0, "u 'RooStats::MCMCInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMCMCCalculator(void) {
   /* RooStats::MCMCCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator));
   G__memfunc_setup("MCMCCalculator",1322,G__G__RooStats_928_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCMCCalculator",1322,G__G__RooStats_928_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_928_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorPdf",1106,G__G__RooStats_928_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_928_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChainParameters",1827,G__G__RooStats_928_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_928_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_928_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProposalFunction",1986,G__G__RooStats_928_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ProposalFunction' - 1 - proposalFunction", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumIters",1123,G__G__RooStats_928_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numIters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumBurnInSteps",1721,G__G__RooStats_928_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numBurnInSteps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumBins",1000,G__G__RooStats_928_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numBins", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxes",701,G__G__RooStats_928_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgList' - 1 - axes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUseKeys",1013,G__G__RooStats_928_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - useKeys", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUseSparseHist",1631,G__G__RooStats_928_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - useSparseHist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetIntervalType",1555,G__G__RooStats_928_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RooStats::MCMCInterval::IntervalType' - 0 - intervalType", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeftSideTailFraction",2300,G__G__RooStats_928_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKeysConfidenceAccuracy",2529,G__G__RooStats_928_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - epsilon", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetKeysTerminationThreshold",2815,G__G__RooStats_928_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupBasicUsage",1512,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBins",696,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'RooAbsCollection' - 11 - coll i - 'Int_t' 0 - numBins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_928_0_29, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MCMCCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_928_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_928_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MCMCCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_928_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MCMCCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_928_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__G__RooStats_928_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_928_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_928_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_928_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCMCCalculator", 1322, G__G__RooStats_928_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::MCMCCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCMCCalculator", 1448, G__G__RooStats_928_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_928_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::MCMCCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMCMCIntervalPlot(void) {
   /* RooStats::MCMCIntervalPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot));
   G__memfunc_setup("MCMCIntervalPlot",1540,G__G__RooStats_991_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCMCIntervalPlot",1540,G__G__RooStats_991_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::MCMCInterval' - 1 - interval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMCMCInterval",1425,G__G__RooStats_991_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::MCMCInterval' - 1 - interval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineColor",1203,G__G__RooStats_991_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineWidth",1204,G__G__RooStats_991_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShadeColor",1296,G__G__RooStats_991_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowBurnIn",1307,G__G__RooStats_991_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - showBurnIn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawChainScatter",1607,G__G__RooStats_991_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooRealVar' - 1 - xVar u 'RooRealVar' - 1 - yVar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawParameterVsTime",1927,G__G__RooStats_991_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooRealVar' - 1 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawNLLVsTime",1228,G__G__RooStats_991_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawNLLHist",1036,G__G__RooStats_991_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawWeightHist",1422,G__G__RooStats_991_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPosterior",1365,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPosteriorHist",1773,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 3, 1, 2, 0, 
"C - 'Option_t' 10 'NULL' options C - - 10 'NULL' title "
"g - 'Bool_t' 0 'kTRUE' scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPosteriorKeysPdf",2059,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPosteriorKeysProduct",2514,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawInterval",1235,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawShortestInterval",2095,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawHistInterval",1643,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawKeysPdfInterval",1929,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTailFractionInterval",2451,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 'NULL' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_991_0_23, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MCMCIntervalPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_991_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCIntervalPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_991_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MCMCIntervalPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_991_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MCMCIntervalPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_991_0_30, 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__G__RooStats_991_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCIntervalPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_991_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCIntervalPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_991_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MCMCIntervalPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_991_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MCMCIntervalPlot::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MCMCIntervalPlot", 1540, G__G__RooStats_991_0_35, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::MCMCIntervalPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MCMCIntervalPlot", 1666, G__G__RooStats_991_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_991_0_37, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot), -1, 1, 1, 1, 1, 0, "u 'RooStats::MCMCIntervalPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMetropolisHastings(void) {
   /* RooStats::MetropolisHastings */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings));
   G__memfunc_setup("MetropolisHastings",1903,G__G__RooStats_992_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MetropolisHastings",1903,G__G__RooStats_992_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsReal' - 1 - function u 'RooArgSet' - 11 - paramsOfInterest "
"u 'RooStats::ProposalFunction' - 1 - proposalFunction i - 'Int_t' 0 - numIters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConstructChain",1448,G__G__RooStats_992_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMarkovChain), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChainParameters",1827,G__G__RooStats_992_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_992_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProposalFunction",1986,G__G__RooStats_992_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ProposalFunction' - 1 - proposalFunction", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumIters",1123,G__G__RooStats_992_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numIters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumBurnInSteps",1721,G__G__RooStats_992_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - numBurnInSteps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunction",1138,G__G__RooStats_992_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsReal' - 1 - function", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSign",701,G__G__RooStats_992_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RooStats::MetropolisHastings::FunctionSign' - 0 - sign", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__RooStats_992_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i 'RooStats::MetropolisHastings::FunctionType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShouldTakeStep",1424,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcNLL",601,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "d - 'Double_t' 0 - xL", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_992_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MetropolisHastings::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_992_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MetropolisHastings::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_992_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MetropolisHastings::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_992_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MetropolisHastings::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_992_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_992_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MetropolisHastings::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_992_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MetropolisHastings::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_992_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MetropolisHastings::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_992_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MetropolisHastings::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("MetropolisHastings", 1903, G__G__RooStats_992_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings), -1, 0, 1, 1, 1, 0, "u 'RooStats::MetropolisHastings' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MetropolisHastings", 2029, G__G__RooStats_992_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_992_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings), -1, 1, 1, 1, 1, 0, "u 'RooStats::MetropolisHastings' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProfileLikelihoodTestStat(void) {
   /* RooStats::ProfileLikelihoodTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat));
   G__memfunc_setup("ProfileLikelihoodTestStat",2577,G__G__RooStats_1006_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProfileLikelihoodTestStat",2577,G__G__RooStats_1006_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat), -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOneSided",1079,G__G__RooStats_1006_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOneSidedDiscovery",2031,G__G__RooStats_1006_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSigned",902,G__G__RooStats_1006_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", "+/- t_mu instead of t_mu>0 with one-sided settings", (void*) NULL, 0);
   G__memfunc_setup("IsTwoSided",991,G__G__RooStats_1006_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOneSidedDiscovery",1919,G__G__RooStats_1006_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlwaysReuseNLL",1671,G__G__RooStats_1006_0_8, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&RooStats::ProfileLikelihoodTestStat::SetAlwaysReuseNLL) ), 0);
   G__memfunc_setup("SetReuseNLL",1046,G__G__RooStats_1006_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOffset",991,G__G__RooStats_1006_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimizer",1248,G__G__RooStats_1006_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - minimizer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStrategy",1151,G__G__RooStats_1006_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - strategy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTolerance",1225,G__G__RooStats_1006_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrintLevel",1329,G__G__RooStats_1006_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - printlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateProfileLikelihood",2572,G__G__RooStats_1006_0_16, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"i - - 0 - type u 'RooAbsData' - 1 - data "
"u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableDetailedOutput",2036,G__G__RooStats_1006_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' e g - - 0 'false' withErrorsAndPulls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDetailedOutput",1741,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_1006_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVarName",982,G__G__RooStats_1006_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPdf",570,G__G__RooStats_1006_0_22, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinNLL",810,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooFitResult), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1006_0_24, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProfileLikelihoodTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1006_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1006_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProfileLikelihoodTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1006_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProfileLikelihoodTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1006_0_31, 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__G__RooStats_1006_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1006_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileLikelihoodTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1006_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1006_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileLikelihoodTestStat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProfileLikelihoodTestStat", 2577, G__G__RooStats_1006_0_36, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::ProfileLikelihoodTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProfileLikelihoodTestStat", 2703, G__G__RooStats_1006_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLMinNLLTestStat(void) {
   /* RooStats::MinNLLTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat));
   G__memfunc_setup("MinNLLTestStat",1350,G__G__RooStats_1008_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinNLLTestStat",1350,G__G__RooStats_1008_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat), -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinNLLTestStat",1350,G__G__RooStats_1008_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::MinNLLTestStat' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__RooStats_1008_0_4, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat), -1, 1, 1, 1, 1, 0, "u 'RooStats::MinNLLTestStat' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOneSided",1079,G__G__RooStats_1008_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOneSidedDiscovery",2031,G__G__RooStats_1008_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReuseNLL",1046,G__G__RooStats_1008_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimizer",1248,G__G__RooStats_1008_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - minimizer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStrategy",1151,G__G__RooStats_1008_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - strategy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTolerance",1225,G__G__RooStats_1008_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrintLevel",1329,G__G__RooStats_1008_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - printlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOffset",991,G__G__RooStats_1008_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - paramsOfInterest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableDetailedOutput",2036,G__G__RooStats_1008_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDetailedOutput",1741,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVarName",982,G__G__RooStats_1008_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1008_0_18, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::MinNLLTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1008_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MinNLLTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1008_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::MinNLLTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1008_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::MinNLLTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1008_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1008_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MinNLLTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1008_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MinNLLTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1008_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::MinNLLTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1008_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::MinNLLTestStat::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MinNLLTestStat", 1476, G__G__RooStats_1008_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLNeymanConstruction(void) {
   /* RooStats::NeymanConstruction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction));
   G__memfunc_setup("NeymanConstruction",1907,G__G__RooStats_1009_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 1 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPointSetInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestStatSampler",1852,G__G__RooStats_1009_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::TestStatSampler' - 1 - sampler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLeftSideTailFraction",2300,G__G__RooStats_1009_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.' leftSideFraction", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameterPointsToTest",2477,G__G__RooStats_1009_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - pointsToTest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Size",411,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConfidenceLevel",1510,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ModelConfig' - 11 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsData' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_1009_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__G__RooStats_1009_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNuisanceParameters",2166,G__G__RooStats_1009_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTestSize",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConfidenceLevel",1810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetConfidenceBelt",1685,G__G__RooStats_1009_0_15, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseAdaptiveSampling",1942,G__G__RooStats_1009_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdditionalNToysFactor",2133,G__G__RooStats_1009_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - fact", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveBeltToFile",1369,G__G__RooStats_1009_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateConfBelt",1377,G__G__RooStats_1009_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestStatSampler",1840,G__G__RooStats_1009_0_20, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLTestStatSampler), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1009_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::NeymanConstruction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1009_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NeymanConstruction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1009_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::NeymanConstruction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1009_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::NeymanConstruction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1009_0_28, 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__G__RooStats_1009_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NeymanConstruction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1009_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NeymanConstruction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1009_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NeymanConstruction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1009_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NeymanConstruction::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("NeymanConstruction", 1907, G__G__RooStats_1009_0_33, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction), -1, 0, 1, 1, 1, 0, "u 'RooStats::NeymanConstruction' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~NeymanConstruction", 2033, G__G__RooStats_1009_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLNumberCountingPdfFactory(void) {
   /* RooStats::NumberCountingPdfFactory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory));
   G__memfunc_setup("NumberCountingPdfFactory",2466,G__G__RooStats_1010_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddModel",762,G__G__RooStats_1010_0_2, 121, -1, -1, 0, 5, 1, 1, 0, 
"D - 'Double_t' 0 - sigExp i - 'Int_t' 0 - nchan "
"U 'RooWorkspace' - 0 - ws C - - 10 '\"CombinedPdf\"' pdfName "
"C - - 10 '\"masterSignal\"' masterSignalName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddData",643,G__G__RooStats_1010_0_3, 121, -1, -1, 0, 6, 1, 1, 0, 
"D - 'Double_t' 0 - mainMeas D - 'Double_t' 0 - bkgMeas "
"D - 'Double_t' 0 - db i - 'Int_t' 0 - nbins "
"U 'RooWorkspace' - 0 - ws C - - 10 '\"NumberCountingData\"' dsName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddExpData",944,G__G__RooStats_1010_0_4, 121, -1, -1, 0, 6, 1, 1, 0, 
"D - 'Double_t' 0 - sigExp D - 'Double_t' 0 - bkgExp "
"D - 'Double_t' 0 - db i - 'Int_t' 0 - nbins "
"U 'RooWorkspace' - 0 - ws C - - 10 '\"ExpectedNumberCountingData\"' dsName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddExpDataWithSideband",2150,G__G__RooStats_1010_0_5, 121, -1, -1, 0, 6, 1, 1, 0, 
"D - 'Double_t' 0 - sigExp D - 'Double_t' 0 - bkgExp "
"D - 'Double_t' 0 - tau i - 'Int_t' 0 - nbins "
"U 'RooWorkspace' - 0 - ws C - - 10 '\"NumberCountingData\"' dsName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDataWithSideband",1849,G__G__RooStats_1010_0_6, 121, -1, -1, 0, 6, 1, 1, 0, 
"D - 'Double_t' 0 - mainMeas D - 'Double_t' 0 - sideband "
"D - 'Double_t' 0 - tau i - 'Int_t' 0 - nbins "
"U 'RooWorkspace' - 0 - ws C - - 10 '\"ExpectedNumberCountingData\"' dsName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SafeObservableCreation",2233,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 3, 1, 4, 0, 
"U 'RooWorkspace' - 0 - ws C - - 10 - varName "
"d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SafeObservableCreation",2233,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooRealVar), -1, 0, 4, 1, 4, 0, 
"U 'RooWorkspace' - 0 - ws C - - 10 - varName "
"d - 'Double_t' 0 - value d - 'Double_t' 0 - maximum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1010_0_9, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::NumberCountingPdfFactory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1010_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumberCountingPdfFactory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1010_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::NumberCountingPdfFactory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1010_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::NumberCountingPdfFactory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_1010_0_13, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_1010_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_1010_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_1010_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1010_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumberCountingPdfFactory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1010_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NumberCountingPdfFactory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1010_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumberCountingPdfFactory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1010_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NumberCountingPdfFactory::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("NumberCountingPdfFactory", 2466, G__G__RooStats_1010_0_21, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory), -1, 0, 1, 1, 1, 0, "u 'RooStats::NumberCountingPdfFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~NumberCountingPdfFactory", 2592, G__G__RooStats_1010_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1010_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory), -1, 1, 1, 1, 1, 0, "u 'RooStats::NumberCountingPdfFactory' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLNumberCountingUtils(void) {
   /* RooStats::NumberCountingUtils */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumberCountingUtils));
   G__memfunc_setup("BinomialExpZ",1202,G__G__RooStats_1011_0_1, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sExp d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - fractionalBUncertainty", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialExpZ) ), 0);
   G__memfunc_setup("BinomialWithTauExpZ",1912,G__G__RooStats_1011_0_2, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sExp d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - tau", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialWithTauExpZ) ), 0);
   G__memfunc_setup("BinomialObsZ",1193,G__G__RooStats_1011_0_3, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nObs d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - fractionalBUncertainty", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialObsZ) ), 0);
   G__memfunc_setup("BinomialWithTauObsZ",1903,G__G__RooStats_1011_0_4, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nObs d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - tau", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialWithTauObsZ) ), 0);
   G__memfunc_setup("BinomialExpP",1192,G__G__RooStats_1011_0_5, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sExp d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - fractionalBUncertainty", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialExpP) ), 0);
   G__memfunc_setup("BinomialWithTauExpP",1902,G__G__RooStats_1011_0_6, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sExp d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - tau", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialWithTauExpP) ), 0);
   G__memfunc_setup("BinomialObsP",1183,G__G__RooStats_1011_0_7, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nObs d - 'Double_t' 0 - - "
"d - 'Double_t' 0 - fractionalBUncertainty", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialObsP) ), 0);
   G__memfunc_setup("BinomialWithTauObsP",1893,G__G__RooStats_1011_0_8, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nObs d - 'Double_t' 0 - bExp "
"d - 'Double_t' 0 - tau", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&RooStats::NumberCountingUtils::BinomialWithTauObsP) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLNumEventsTestStat(void) {
   /* RooStats::NumEventsTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat));
   G__memfunc_setup("NumEventsTestStat",1761,G__G__RooStats_1012_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumEventsTestStat",1761,G__G__RooStats_1012_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat), -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestStatistic",1656,G__G__RooStats_1012_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsArg), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1012_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::NumEventsTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1012_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumEventsTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1012_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::NumEventsTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1012_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::NumEventsTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1012_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1012_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumEventsTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1012_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NumEventsTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1012_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::NumEventsTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1012_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::NumEventsTestStat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("NumEventsTestStat", 1761, G__G__RooStats_1012_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::NumEventsTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~NumEventsTestStat", 1887, G__G__RooStats_1012_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1012_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat), -1, 1, 1, 1, 1, 0, "u 'RooStats::NumEventsTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLPdfProposal(void) {
   /* RooStats::PdfProposal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal));
   G__memfunc_setup("PdfProposal",1130,G__G__RooStats_1013_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PdfProposal",1130,G__G__RooStats_1013_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal), -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Propose",744,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - xPrime u 'RooArgSet' - 1 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalDensity",1872,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_1013_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPdf",570,G__G__RooStats_1013_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsPdf), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddMapping",981,G__G__RooStats_1013_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooRealVar' - 1 - proposalParam u 'RooAbsReal' - 1 - update", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__RooStats_1013_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("printMappings",1388,G__G__RooStats_1013_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheSize",1179,G__G__RooStats_1013_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOwnsPdf",1005,G__G__RooStats_1013_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ownsPdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Equals",619,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1013_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::PdfProposal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1013_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PdfProposal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1013_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::PdfProposal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1013_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::PdfProposal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1013_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1013_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PdfProposal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1013_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::PdfProposal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1013_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::PdfProposal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1013_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::PdfProposal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PdfProposal", 1130, G__G__RooStats_1013_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal), -1, 0, 1, 1, 1, 0, "u 'RooStats::PdfProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PdfProposal", 1256, G__G__RooStats_1013_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1013_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLPdfProposal), -1, 1, 1, 1, 1, 0, "u 'RooStats::PdfProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProfileInspector(void) {
   /* RooStats::ProfileInspector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector));
   G__memfunc_setup("ProfileInspector",1672,G__G__RooStats_1023_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfProfilePlots",2132,G__G__RooStats_1023_0_2, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TList), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data U 'RooStats::ModelConfig' - 0 - config", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1023_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProfileInspector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1023_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileInspector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1023_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProfileInspector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1023_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProfileInspector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__RooStats_1023_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__RooStats_1023_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__RooStats_1023_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__RooStats_1023_0_10, 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__G__RooStats_1023_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileInspector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1023_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileInspector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1023_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileInspector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1023_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileInspector::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProfileInspector", 1672, G__G__RooStats_1023_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector), -1, 0, 1, 1, 1, 0, "u 'RooStats::ProfileInspector' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProfileInspector", 1798, G__G__RooStats_1023_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1023_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileInspector), -1, 1, 1, 1, 1, 0, "u 'RooStats::ProfileInspector' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProfileLikelihoodCalculator(void) {
   /* RooStats::ProfileLikelihoodCalculator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator));
   G__memfunc_setup("ProfileLikelihoodCalculator",2783,G__G__RooStats_1024_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProfileLikelihoodCalculator",2783,G__G__RooStats_1024_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator), -1, 0, 5, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooAbsPdf' - 1 - pdf "
"u 'RooArgSet' - 11 - paramsOfInterest d - 'Double_t' 0 '0.05' size "
"U 'RooArgSet' - 10 '0' nullParams", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProfileLikelihoodCalculator",2783,G__G__RooStats_1024_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator), -1, 0, 3, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooStats::ModelConfig' - 1 - model "
"d - 'Double_t' 0 '0.05' size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterval",1125,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHypoTest",1120,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLHypoTestResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoReset",694,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoGlobalFit",1063,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1024_0_8, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProfileLikelihoodCalculator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1024_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodCalculator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1024_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProfileLikelihoodCalculator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1024_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProfileLikelihoodCalculator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1024_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__G__RooStats_1024_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodCalculator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1024_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileLikelihoodCalculator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1024_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProfileLikelihoodCalculator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1024_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProfileLikelihoodCalculator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProfileLikelihoodCalculator", 2783, G__G__RooStats_1024_0_20, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator), -1, 0, 1, 1, 1, 0, "u 'RooStats::ProfileLikelihoodCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProfileLikelihoodCalculator", 2909, G__G__RooStats_1024_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1024_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator), -1, 1, 1, 1, 1, 0, "u 'RooStats::ProfileLikelihoodCalculator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLUniformProposal(void) {
   /* RooStats::UniformProposal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal));
   G__memfunc_setup("UniformProposal",1584,G__G__RooStats_1025_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Propose",744,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - xPrime u 'RooArgSet' - 1 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalDensity",1872,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1025_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::UniformProposal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1025_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UniformProposal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1025_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::UniformProposal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1025_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::UniformProposal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1025_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1025_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UniformProposal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1025_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::UniformProposal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1025_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UniformProposal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1025_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::UniformProposal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("UniformProposal", 1584, G__G__RooStats_1025_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal), -1, 0, 1, 1, 1, 0, "u 'RooStats::UniformProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~UniformProposal", 1710, G__G__RooStats_1025_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1025_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUniformProposal), -1, 1, 1, 1, 1, 0, "u 'RooStats::UniformProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLProposalHelper(void) {
   /* RooStats::ProposalHelper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper));
   G__memfunc_setup("ProposalHelper",1456,G__G__RooStats_1026_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPdf",582,G__G__RooStats_1026_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClues",808,G__G__RooStats_1026_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooDataSet' - 1 - clues", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalFunction",1974,G__G__RooStats_1026_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalFunction), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheSize",1179,G__G__RooStats_1026_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUpdateProposalParameters",2803,G__G__RooStats_1026_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - updateParams", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariables",1221,G__G__RooStats_1026_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgList' - 1 - vars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariables",1221,G__G__RooStats_1026_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgList' - 11 - vars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUniformFraction",1858,G__G__RooStats_1026_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - uniFrac", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCluesFraction",1630,G__G__RooStats_1026_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cluesFrac", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCovMatrix",1225,G__G__RooStats_1026_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - covMatrix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWidthRangeDivisor",2041,G__G__RooStats_1026_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - divisor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCluesOptions",1556,G__G__RooStats_1026_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariables",1221,G__G__RooStats_1026_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - vars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePdf",878,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateCluesPdf",1386,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateUniformPdf",1614,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateCovMatrix",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'RooArgList' - 1 - xVec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1026_0_19, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ProposalHelper::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1026_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalHelper::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1026_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ProposalHelper::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1026_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ProposalHelper::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1026_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1026_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalHelper::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1026_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProposalHelper::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1026_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ProposalHelper::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1026_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ProposalHelper::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ProposalHelper", 1456, G__G__RooStats_1026_0_31, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLProposalHelper), -1, 0, 1, 1, 1, 0, "u 'RooStats::ProposalHelper' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ProposalHelper", 1582, G__G__RooStats_1026_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLRatioOfProfiledLikelihoodsTestStat(void) {
   /* RooStats::RatioOfProfiledLikelihoodsTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat));
   G__memfunc_setup("RatioOfProfiledLikelihoodsTestStat",3484,G__G__RooStats_1027_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RatioOfProfiledLikelihoodsTestStat",3484,G__G__RooStats_1027_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat), -1, 0, 3, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - nullPdf u 'RooAbsPdf' - 1 - altPdf "
"U 'RooArgSet' - 10 '0' altPOI", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProfiledLikelihood",1849,G__G__RooStats_1027_0_3, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - poi "
"u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - nullParamsOfInterest", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableDetailedOutput",2036,G__G__RooStats_1027_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAlwaysReuseNLL",1671,G__G__RooStats_1027_0_6, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&RooStats::RatioOfProfiledLikelihoodsTestStat::SetAlwaysReuseNLL) ), 0);
   G__memfunc_setup("SetReuseNLL",1046,G__G__RooStats_1027_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimizer",1248,G__G__RooStats_1027_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - minimizer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStrategy",1151,G__G__RooStats_1027_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - strategy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTolerance",1225,G__G__RooStats_1027_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrintLevel",1329,G__G__RooStats_1027_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - printLevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_1027_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDetailedOutput",1741,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSubtractMLE",1362,G__G__RooStats_1027_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - subtract", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1027_0_16, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1027_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1027_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1027_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1027_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1027_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1027_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1027_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1027_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::RatioOfProfiledLikelihoodsTestStat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("RatioOfProfiledLikelihoodsTestStat", 3484, G__G__RooStats_1027_0_28, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::RatioOfProfiledLikelihoodsTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~RatioOfProfiledLikelihoodsTestStat", 3610, G__G__RooStats_1027_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSequentialProposal(void) {
   /* RooStats::SequentialProposal */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal));
   G__memfunc_setup("SequentialProposal",1899,G__G__RooStats_1028_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SequentialProposal",1899,G__G__RooStats_1028_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal), -1, 0, 1, 1, 1, 0, "d - - 0 - divisor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Propose",744,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - xPrime u 'RooArgSet' - 1 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalDensity",1872,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooArgSet' - 1 - x1 u 'RooArgSet' - 1 - x2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1028_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SequentialProposal::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1028_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SequentialProposal::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1028_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SequentialProposal::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1028_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SequentialProposal::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1028_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1028_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SequentialProposal::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1028_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SequentialProposal::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1028_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SequentialProposal::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1028_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SequentialProposal::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SequentialProposal", 1899, G__G__RooStats_1028_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal), -1, 0, 1, 1, 1, 0, "u 'RooStats::SequentialProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SequentialProposal", 2025, G__G__RooStats_1028_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1028_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSequentialProposal), -1, 1, 1, 1, 1, 0, "u 'RooStats::SequentialProposal' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSimpleLikelihoodRatioTestStat(void) {
   /* RooStats::SimpleLikelihoodRatioTestStat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat));
   G__memfunc_setup("SimpleLikelihoodRatioTestStat",2985,G__G__RooStats_1029_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimpleLikelihoodRatioTestStat",2985,G__G__RooStats_1029_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat), -1, 0, 2, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - nullPdf u 'RooAbsPdf' - 1 - altPdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimpleLikelihoodRatioTestStat",2985,G__G__RooStats_1029_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat), -1, 0, 4, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - nullPdf u 'RooAbsPdf' - 1 - altPdf "
"u 'RooArgSet' - 11 - nullParameters u 'RooArgSet' - 11 - altParameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlwaysReuseNLL",1671,G__G__RooStats_1029_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&RooStats::SimpleLikelihoodRatioTestStat::SetAlwaysReuseNLL) ), 0);
   G__memfunc_setup("SetReuseNLL",1046,G__G__RooStats_1029_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNullParameters",1755,G__G__RooStats_1029_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - nullParameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAltParameters",1633,G__G__RooStats_1029_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - altParameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParamsAreEqual",1396,G__G__RooStats_1029_0_8, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_1029_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Evaluate",823,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'RooAbsData' - 1 - data u 'RooArgSet' - 1 - nullPOI", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EnableDetailedOutput",2036,G__G__RooStats_1029_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDetailedOutput",1741,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgSet), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVarName",970,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__RooStatsLN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1029_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SimpleLikelihoodRatioTestStat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1029_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleLikelihoodRatioTestStat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1029_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SimpleLikelihoodRatioTestStat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1029_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SimpleLikelihoodRatioTestStat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1029_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1029_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleLikelihoodRatioTestStat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1029_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SimpleLikelihoodRatioTestStat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1029_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SimpleLikelihoodRatioTestStat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1029_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SimpleLikelihoodRatioTestStat::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SimpleLikelihoodRatioTestStat", 2985, G__G__RooStats_1029_0_26, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat), -1, 0, 1, 1, 1, 0, "u 'RooStats::SimpleLikelihoodRatioTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SimpleLikelihoodRatioTestStat", 3111, G__G__RooStats_1029_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1029_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat), -1, 1, 1, 1, 1, 0, "u 'RooStats::SimpleLikelihoodRatioTestStat' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLSPlot(void) {
   /* RooStats::SPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot));
   G__memfunc_setup("SPlot",498,G__G__RooStats_1031_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SPlot",498,G__G__RooStats_1031_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 0, 1, 1, 1, 0, "u 'RooStats::SPlot' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SPlot",498,G__G__RooStats_1031_0_3, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SPlot",498,G__G__RooStats_1031_0_4, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooDataSet' - 11 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SPlot",498,G__G__RooStats_1031_0_5, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"u 'RooDataSet' - 1 - data U 'RooAbsPdf' - 0 - pdf "
"u 'RooArgList' - 11 - yieldsList u 'RooArgSet' - 11 'RooArgSet()' projDeps "
"g - - 0 'kTRUE' includeWeights g - - 0 'kFALSE' copyDataSet "
"C - - 10 '\"\"' newName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSData",761,G__G__RooStats_1031_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSDataSet",1049,G__G__RooStats_1031_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSWeightVars",1399,G__G__RooStats_1031_0_8, 117, G__get_linked_tagnum(&G__G__RooStatsLN_RooArgList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumSWeightVars",1703,G__G__RooStats_1031_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSWeight",964,G__G__RooStats_1031_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'RooAbsPdf' - 0 - pdf u 'RooArgList' - 11 - yieldsTmp "
"u 'RooArgSet' - 11 'RooArgSet()' projDeps g - - 0 'kTRUE' includeWeights", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumOfEventSWeight",1991,G__G__RooStats_1031_0_11, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - numEvent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYieldFromSWeight",1894,G__G__RooStats_1031_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "C - - 10 - sVariable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSWeight",987,G__G__RooStats_1031_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - numEvent C - - 10 - sVariable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1031_0_14, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::SPlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1031_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SPlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1031_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::SPlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1031_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::SPlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1031_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1031_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SPlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1031_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SPlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1031_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::SPlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1031_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::SPlot::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~SPlot", 624, G__G__RooStats_1031_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1031_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLSPlot), -1, 1, 1, 1, 1, 0, "u 'RooStats::SPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLToyMCImportanceSampler(void) {
   /* RooStats::ToyMCImportanceSampler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler));
   G__memfunc_setup("ToyMCImportanceSampler",2226,G__G__RooStats_1034_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToyMCImportanceSampler",2226,G__G__RooStats_1034_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler), -1, 0, 2, 1, 1, 0, 
"u 'RooStats::TestStatistic' - 1 - ts i - 'Int_t' 0 - ntoys", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamplingDistributionsSingleWorker",3754,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 1 - paramPoint", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 2, 1, 1, 8, 
"u 'RooArgSet' - 1 - paramPoint d - - 1 - weight", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_1034_0_5, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 4, 1, 1, 8, 
"u 'RooArgSet' - 1 - paramPoint d - - 1 - weight "
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - impNLLs d - - 1 - nullNLL", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_1034_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - weights", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenerateToyData",1505,G__G__RooStats_1034_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsData), -1, 0, 3, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - weights u 'vector<double,allocator<double> >' 'vector<double>' 1 - nullNLLs "
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - impNLLs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDensityToGenerateFromByIndex",3137,G__G__RooStats_1034_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - i g - - 0 'false' fromNull", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddImportanceDensity",2043,G__G__RooStats_1034_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RooAbsPdf' - 0 - p U 'RooArgSet' - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNullDensity",1412,G__G__RooStats_1034_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'RooAbsPdf' - 0 - p U 'RooArgSet' - 10 'NULL' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPdf",582,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooAbsPdf' - 1 - pdf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParametersForTestStat",2467,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - nullpoi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetApplyVeto",1232,G__G__RooStats_1034_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReuseNLL",1046,G__G__RooStats_1034_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConditionalObservables",2584,G__G__RooStats_1034_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateNImpDensitiesForOnePOI",2721,G__G__RooStats_1034_0_16, 105, -1, -1, 0, 5, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - allPOI "
"u 'RooRealVar' - 1 - poi i - - 0 - n "
"d - - 0 '0.0' poiValueForBackground", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateImpDensitiesForOnePOIAdaptively",3686,G__G__RooStats_1034_0_17, 105, -1, -1, 0, 5, 1, 1, 0, 
"u 'RooAbsPdf' - 1 - pdf u 'RooArgSet' - 11 - allPOI "
"u 'RooRealVar' - 1 - poi d - - 0 '0.5' nStdDevOverlap "
"d - - 0 '0.0' poiValueForBackground", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEqualNumToysPerDensity",2570,G__G__RooStats_1034_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExpIncreasingNumToysPerDensity",3394,G__G__RooStats_1034_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearCache",955,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1034_0_21, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ToyMCImportanceSampler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1034_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCImportanceSampler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1034_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ToyMCImportanceSampler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1034_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ToyMCImportanceSampler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1034_0_28, 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__G__RooStats_1034_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCImportanceSampler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1034_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCImportanceSampler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1034_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCImportanceSampler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1034_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCImportanceSampler::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ToyMCImportanceSampler", 2226, G__G__RooStats_1034_0_33, (int) ('i'), 
G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler), -1, 0, 1, 1, 1, 0, "u 'RooStats::ToyMCImportanceSampler' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ToyMCImportanceSampler", 2352, G__G__RooStats_1034_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLToyMCStudy(void) {
   /* RooStats::ToyMCStudy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy));
   G__memfunc_setup("ToyMCStudy",997,G__G__RooStats_1042_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"ToyMCStudy\"' name C - - 10 '\"ToyMCStudy\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clone",529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooAbsStudy), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("initialize",1074,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("execute",755,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("finalize",850,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("merge",528,G__G__RooStats_1042_0_6, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToyMCSampler",1484,G__G__RooStats_1042_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooStats::ToyMCSampler' - 1 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParamPoint",1319,G__G__RooStats_1042_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'RooArgSet' - 11 - paramPoint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1042_0_9, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ToyMCStudy::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1042_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCStudy::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1042_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ToyMCStudy::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1042_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ToyMCStudy::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1042_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1042_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCStudy::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1042_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCStudy::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1042_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCStudy::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1042_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCStudy::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ToyMCStudy", 997, G__G__RooStats_1042_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy), -1, 0, 1, 1, 1, 0, "u 'RooStats::ToyMCStudy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ToyMCStudy", 1123, G__G__RooStats_1042_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1042_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCStudy), -1, 1, 1, 1, 1, 0, "u 'RooStats::ToyMCStudy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLToyMCPayload(void) {
   /* RooStats::ToyMCPayload */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload));
   G__memfunc_setup("ToyMCPayload",1174,G__G__RooStats_1043_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToyMCPayload",1174,G__G__RooStats_1043_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload), -1, 0, 1, 1, 1, 0, "U 'RooDataSet' - 0 - sd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSamplingDistributions",2510,G__G__RooStats_1043_0_3, 85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__RooStats_1043_0_4, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::ToyMCPayload::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1043_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCPayload::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1043_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::ToyMCPayload::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1043_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::ToyMCPayload::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1043_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1043_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCPayload::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1043_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCPayload::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1043_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::ToyMCPayload::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1043_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::ToyMCPayload::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("ToyMCPayload", 1174, G__G__RooStats_1043_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload), -1, 0, 1, 1, 1, 0, "u 'RooStats::ToyMCPayload' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ToyMCPayload", 1300, G__G__RooStats_1043_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__RooStats_1043_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLToyMCPayload), -1, 1, 1, 1, 1, 0, "u 'RooStats::ToyMCPayload' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncRooStatscLcLUpperLimitMCSModule(void) {
   /* RooStats::UpperLimitMCSModule */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule));
   G__memfunc_setup("UpperLimitMCSModule",1876,G__G__RooStats_1049_0_1, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule), -1, 0, 2, 1, 1, 0, 
"U 'RooArgSet' - 10 - poi d - 'Double_t' 0 '0.95' CL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimitMCSModule",1876,G__G__RooStats_1049_0_2, 105, G__get_linked_tagnum(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule), -1, 0, 1, 1, 1, 0, "u 'RooStats::UpperLimitMCSModule' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("initializeInstance",1895,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("initializeRun",1383,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("finalizeRun",1159,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_RooDataSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("processBetweenGenAndFit",2329,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__RooStats_1049_0_7, 85, G__get_linked_tagnum(&G__G__RooStatsLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&RooStats::UpperLimitMCSModule::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__RooStats_1049_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UpperLimitMCSModule::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__RooStats_1049_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&RooStats::UpperLimitMCSModule::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__RooStats_1049_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&RooStats::UpperLimitMCSModule::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__RooStatsLN_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__G__RooStats_1049_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__RooStats_1049_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UpperLimitMCSModule::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__RooStats_1049_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::UpperLimitMCSModule::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__RooStats_1049_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&RooStats::UpperLimitMCSModule::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__RooStats_1049_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&RooStats::UpperLimitMCSModule::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~UpperLimitMCSModule", 2002, G__G__RooStats_1049_0_19, (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_memfuncG__RooStats() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__RooStats() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {
}

static void G__cpp_setup_func28() {
}

static void G__cpp_setup_func29() {
}

static void G__cpp_setup_func30() {
}

static void G__cpp_setup_func31() {
}

static void G__cpp_setup_func32() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__RooStats() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
  G__cpp_setup_func28();
  G__cpp_setup_func29();
  G__cpp_setup_func30();
  G__cpp_setup_func31();
  G__cpp_setup_func32();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__RooStatsLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__RooStatsLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsData = { "RooAbsData" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooWorkspace = { "RooWorkspace" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStats = { "RooStats" , 110 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestResult = { "RooStats::HypoTestResult" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLModelConfig = { "RooStats::ModelConfig" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestCalculator = { "RooStats::HypoTestCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TIterator = { "TIterator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooPrintable = { "RooPrintable" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsArg = { "RooAbsArg" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooArgSet = { "RooArgSet" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsCollection = { "RooAbsCollection" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooArgList = { "RooArgList" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooRealProxy = { "RooRealProxy" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooProdPdf = { "RooProdPdf" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR = { "set<string,less<string>,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR = { "map<string,string,less<string>,allocator<pair<const string,string> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR = { "set<pair<RooAbsArg*,RooAbsArg*>,less<pair<RooAbsArg*,RooAbsArg*> >,allocator<pair<RooAbsArg*,RooAbsArg*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsReal = { "RooAbsReal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_dequelERooAbsCachemUcOallocatorlERooAbsCachemUgRsPgR = { "deque<RooAbsCache*,allocator<RooAbsCache*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooDataSet = { "RooDataSet" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplERooAbsArgmUcOTRefArraymUcOlesslERooAbsArgmUgRcOallocatorlEpairlERooAbsArgmUsPconstcOTRefArraymUgRsPgRsPgR = { "map<RooAbsArg*,TRefArray*,less<RooAbsArg*>,allocator<pair<RooAbsArg* const,TRefArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_dequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR = { "deque<RooAbsArg*,allocator<RooAbsArg*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_stacklERooAbsArgmUcOdequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRsPgR = { "stack<RooAbsArg*,deque<RooAbsArg*,allocator<RooAbsArg*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooCmdArg = { "RooCmdArg" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooRealVar = { "RooRealVar" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR = { "vector<RooCurve*,allocator<RooCurve*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooCurvemUcOallocatorlERooCurvemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooCurve*,allocator<RooCurve*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlEdoublecOallocatorlEdoublegRsPgR = { "list<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooDataHist = { "RooDataHist" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooFitResult = { "RooFitResult" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsPdf = { "RooAbsPdf" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooCategory = { "RooCategory" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR = { "map<string,TH1*,less<string>,allocator<pair<const string,TH1*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR = { "map<string,RooDataHist*,less<string>,allocator<pair<const string,RooDataHist*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR = { "map<string,RooDataSet*,less<string>,allocator<pair<const string,RooDataSet*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR = { "map<string,RooAbsData*,less<string>,allocator<pair<const string,RooAbsData*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooPlot = { "RooPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgR = { "list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_pairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgR = { "pair<string,list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> > >" , 115 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR = { "map<const RooAbsArg*,pair<string,list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> > >,less<const RooAbsArg*>,allocator<pair<const RooAbsArg* const,pair<string,list<RooAbsReal::EvalError,allocator<RooAbsReal::EvalError> > > > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR = { "vector<pair<const RooArgSet*,const RooArgSet*>,allocator<pair<const RooArgSet*,const RooArgSet*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<const RooArgSet*,const RooArgSet*>,allocator<pair<const RooArgSet*,const RooArgSet*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR = { "map<pair<const RooArgSet*,const RooArgSet*>,unsigned long,less<pair<const RooArgSet*,const RooArgSet*> >,allocator<pair<const pair<const RooArgSet*,const RooArgSet*>,unsigned long> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR = { "map<int,string,less<int>,allocator<pair<const int,string> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR = { "vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_dequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgR = { "deque<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> >,allocator<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR = { "stack<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> >,deque<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> >,allocator<vector<RooMsgService::StreamConfig,allocator<RooMsgService::StreamConfig> > > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR = { "map<string,basic_ostream<char,char_traits<char> >*,less<string>,allocator<pair<const string,basic_ostream<char,char_traits<char> >*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR = { "vector<RooNormSetCache,allocator<RooNormSetCache> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooNormSetCache,allocator<RooNormSetCache> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR = { "vector<RooAbsCacheElement*,allocator<RooAbsCacheElement*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooAbsCacheElement*,allocator<RooAbsCacheElement*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsPdfcLcLGenSpec = { "RooAbsPdf::GenSpec" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETClassmUcOintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOintgRsPgRsPgR = { "map<TClass*,int,less<TClass*>,allocator<pair<TClass* const,int> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR = { "map<string,int,less<string>,allocator<pair<const string,int> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_pairlEstringcOintgR = { "pair<string,int>" , 115 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR = { "map<TString,double,less<TString>,allocator<pair<const TString,double> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR = { "map<TString,int,less<TString>,allocator<pair<const TString,int> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR = { "map<TString,RooExpensiveObjectCache::ExpensiveObject*,less<TString>,allocator<pair<const TString,RooExpensiveObjectCache::ExpensiveObject*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsStudy = { "RooAbsStudy" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsDatamUcOallocatorlERooAbsDatamUgRsPgR = { "list<RooAbsData*,allocator<RooAbsData*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlETObjectmUcOallocatorlETObjectmUgRsPgR = { "list<TObject*,allocator<TObject*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR = { "map<TString,RooWorkspace::CodeRepo::ClassRelInfo,less<TString>,allocator<pair<const TString,RooWorkspace::CodeRepo::ClassRelInfo> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR = { "map<TString,RooWorkspace::CodeRepo::ClassFiles,less<TString>,allocator<pair<const TString,RooWorkspace::CodeRepo::ClassFiles> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR = { "map<TString,RooWorkspace::CodeRepo::ExtraHeader,less<TString>,allocator<pair<const TString,RooWorkspace::CodeRepo::ExtraHeader> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR = { "list<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR = { "map<string,RooArgSet,less<string>,allocator<pair<const string,RooArgSet> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TRef = { "TRef" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLTestStatistic = { "RooStats::TestStatistic" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSamplingDistribution = { "RooStats::SamplingDistribution" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLTestStatSampler = { "RooStats::TestStatSampler" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooDataSetmUcOallocatorlERooDataSetmUgRsPgR = { "list<RooDataSet*,allocator<RooDataSet*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR = { "map<string,RooSharedProperties*,less<string>,allocator<pair<const string,RooSharedProperties*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR = { "vector<vector<int,allocator<int> >,allocator<vector<int,allocator<int> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<int,allocator<int> >,allocator<vector<int,allocator<int> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR = { "vector<RooArgSet*,allocator<RooArgSet*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooArgSet*,allocator<RooArgSet*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR = { "vector<RooAbsReal*,allocator<RooAbsReal*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooAbsReal*,allocator<RooAbsReal*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric = { "RooStats::HypoTestCalculatorGeneric" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator = { "RooStats::AsymptoticCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_ROOTcLcLMathcLcLIBaseFunctionOneDim = { "ROOT::Math::IBaseFunctionOneDim" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLConfInterval = { "RooStats::ConfInterval" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLIntervalCalculator = { "RooStats::IntervalCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSimpleInterval = { "RooStats::SimpleInterval" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLBayesianCalculator = { "RooStats::BayesianCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLBernsteinCorrection = { "RooStats::BernsteinCorrection" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLCombinedCalculator = { "RooStats::CombinedCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup = { "RooStats::SamplingSummaryLookup" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<int,pair<double,double>,less<int>,allocator<pair<const int,pair<double,double> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLAcceptanceRegion = { "RooStats::AcceptanceRegion" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSamplingSummary = { "RooStats::SamplingSummary" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR = { "map<int,RooStats::AcceptanceRegion,less<int>,allocator<pair<const int,RooStats::AcceptanceRegion> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLConfidenceBelt = { "RooStats::ConfidenceBelt" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR = { "vector<RooStats::SamplingSummary,allocator<RooStats::SamplingSummary> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooStats::SamplingSummary,allocator<RooStats::SamplingSummary> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLDebuggingSampler = { "RooStats::DebuggingSampler" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsStudymUcOallocatorlERooAbsStudymUgRsPgR = { "list<RooAbsStudy*,allocator<RooAbsStudy*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProofConfig = { "RooStats::ProofConfig" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator = { "RooStats::DetailedOutputAggregator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLNuisanceParametersSampler = { "RooStats::NuisanceParametersSampler" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLToyMCSampler = { "RooStats::ToyMCSampler" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR = { "vector<RooStats::TestStatistic*,allocator<RooStats::TestStatistic*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooStats::TestStatistic*,allocator<RooStats::TestStatistic*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR = { "list<RooAbsPdf*,allocator<RooAbsPdf*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR = { "list<RooArgSet*,allocator<RooArgSet*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsPdfcLcLGenSpecmUcOallocatorlERooAbsPdfcLcLGenSpecmUgRsPgR = { "list<RooAbsPdf::GenSpec*,allocator<RooAbsPdf::GenSpec*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLDebuggingTestStat = { "RooStats::DebuggingTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLPointSetInterval = { "RooStats::PointSetInterval" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLFeldmanCousins = { "RooStats::FeldmanCousins" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR = { "vector<pair<string,int>,allocator<pair<string,int> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<string,int>,allocator<pair<string,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLFrequentistCalculator = { "RooStats::FrequentistCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHeaviside = { "RooStats::Heaviside" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHLFactory = { "RooStats::HLFactory" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHybridCalculator = { "RooStats::HybridCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHybridPlot = { "RooStats::HybridPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHybridResult = { "RooStats::HybridResult" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal = { "RooStats::HybridCalculatorOriginal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TLine = { "TLine" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TLegend = { "TLegend" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult = { "RooStats::HypoTestInverterResult" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t = { "RooStats::HypoTestInverterResult::InterpolOption_t" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_TGraphErrors = { "TGraphErrors" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInverter = { "RooStats::HypoTestInverter" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType = { "RooStats::HypoTestInverter::ECalculatorType" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_auto_ptrlETGraphErrorsgR = { "auto_ptr<TGraphErrors>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_auto_ptrlERooStatscLcLHypoTestCalculatorGenericgR = { "auto_ptr<RooStats::HypoTestCalculatorGeneric>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal = { "RooStats::HypoTestInverterOriginal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_TMultiGraph = { "TMultiGraph" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSamplingDistPlot = { "RooStats::SamplingDistPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot = { "RooStats::HypoTestInverterPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooList = { "RooList" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLHypoTestPlot = { "RooStats::HypoTestPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLLikelihoodInterval = { "RooStats::LikelihoodInterval" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR = { "map<string,double,less<string>,allocator<pair<const string,double> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR = { "auto_ptr<ROOT::Math::Minimizer>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_auto_ptrlERooFunctorgR = { "auto_ptr<RooFunctor>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "auto_ptr<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot = { "RooStats::LikelihoodIntervalPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<const RooAbsArg*,pair<double,double>,less<const RooAbsArg*>,allocator<pair<const RooAbsArg* const,pair<double,double> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooCacheManagerlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgR = { "RooCacheManager<vector<double,allocator<double> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR = { "vector<vector<double,allocator<double> >*,allocator<vector<double,allocator<double> >*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >*,allocator<vector<double,allocator<double> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR = { "vector<RooAbsLValue*,allocator<RooAbsLValue*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooAbsLValue*,allocator<RooAbsLValue*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR = { "vector<const RooAbsBinning*,allocator<const RooAbsBinning*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const RooAbsBinning*,allocator<const RooAbsBinning*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_THnSparse = { "THnSparse" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMarkovChain = { "RooStats::MarkovChain" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR = { "vector<RooFit::MPSplit,allocator<RooFit::MPSplit> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooFit::MPSplit,allocator<RooFit::MPSplit> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR = { "vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<unsigned int,pair<double,double>,less<unsigned int>,allocator<pair<const unsigned int,pair<double,double> > > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR = { "vector<RooAbsArg*,allocator<RooAbsArg*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooAbsArg*,allocator<RooAbsArg*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat = { "RooStats::MaxLikelihoodEstimateTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProposalFunction = { "RooStats::ProposalFunction" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooNDKeysPdf = { "RooNDKeysPdf" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooProduct = { "RooProduct" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMCMCInterval = { "RooStats::MCMCInterval" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLdA = { "RooStats::MCMCInterval::$" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType = { "RooStats::MCMCInterval::IntervalType" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMCMCCalculator = { "RooStats::MCMCCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR = { "map<int,bool,less<int>,allocator<pair<const int,bool> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR = { "vector<TVectorT<double>,allocator<TVectorT<double> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVectorT<double>,allocator<TVectorT<double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR = { "map<pair<string,int>,RooNDKeysPdf::BoxInfo*,less<pair<string,int> >,allocator<pair<const pair<string,int>,RooNDKeysPdf::BoxInfo*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot = { "RooStats::MCMCIntervalPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMetropolisHastings = { "RooStats::MetropolisHastings" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign = { "RooStats::MetropolisHastings::FunctionSign" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType = { "RooStats::MetropolisHastings::FunctionType" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR = { "map<string,bool,less<string>,allocator<pair<const string,bool> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat = { "RooStats::ProfileLikelihoodTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType = { "RooStats::ProfileLikelihoodTestStat::LimitType" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLMinNLLTestStat = { "RooStats::MinNLLTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLNeymanConstruction = { "RooStats::NeymanConstruction" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory = { "RooStats::NumberCountingPdfFactory" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLNumberCountingUtils = { "RooStats::NumberCountingUtils" , 110 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLNumEventsTestStat = { "RooStats::NumEventsTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLPdfProposal = { "RooStats::PdfProposal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR = { "map<RooRealVar*,RooAbsReal*,less<RooRealVar*>,allocator<pair<RooRealVar* const,RooAbsReal*> > >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgRcLcLiterator = { "map<RooRealVar*,RooAbsReal*,less<RooRealVar*>,allocator<pair<RooRealVar* const,RooAbsReal*> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProfileInspector = { "RooStats::ProfileInspector" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator = { "RooStats::ProfileLikelihoodCalculator" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLUniformProposal = { "RooStats::UniformProposal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLProposalHelper = { "RooStats::ProposalHelper" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat = { "RooStats::RatioOfProfiledLikelihoodsTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSequentialProposal = { "RooStats::SequentialProposal" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat = { "RooStats::SimpleLikelihoodRatioTestStat" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSPlot = { "RooStats::SPlot" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLSPlotcLcLdA = { "RooStats::SPlot::$" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLtoysStrategies = { "RooStats::toysStrategies" , 101 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler = { "RooStats::ToyMCImportanceSampler" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR = { "vector<RooAbsPdf*,allocator<RooAbsPdf*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<RooAbsPdf*,allocator<RooAbsPdf*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR = { "vector<const RooArgSet*,allocator<const RooArgSet*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const RooArgSet*,allocator<const RooArgSet*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLToyMCStudy = { "RooStats::ToyMCStudy" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLToyMCPayload = { "RooStats::ToyMCPayload" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooAbsMCStudyModule = { "RooAbsMCStudyModule" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_listlERooAbsMCStudyModulemUcOallocatorlERooAbsMCStudyModulemUgRsPgR = { "list<RooAbsMCStudyModule*,allocator<RooAbsMCStudyModule*> >" , 99 , -1 };
G__linked_taginfo G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule = { "RooStats::UpperLimitMCSModule" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__RooStats() {
  G__G__RooStatsLN_TClass.tagnum = -1 ;
  G__G__RooStatsLN_TBuffer.tagnum = -1 ;
  G__G__RooStatsLN_TMemberInspector.tagnum = -1 ;
  G__G__RooStatsLN_TObject.tagnum = -1 ;
  G__G__RooStatsLN_TNamed.tagnum = -1 ;
  G__G__RooStatsLN_TString.tagnum = -1 ;
  G__G__RooStatsLN_ROOT.tagnum = -1 ;
  G__G__RooStatsLN_string.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_TList.tagnum = -1 ;
  G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsData.tagnum = -1 ;
  G__G__RooStatsLN_RooWorkspace.tagnum = -1 ;
  G__G__RooStatsLN_RooStats.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestResult.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLModelConfig.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestCalculator.tagnum = -1 ;
  G__G__RooStatsLN_TIterator.tagnum = -1 ;
  G__G__RooStatsLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__RooStatsLN_RooPrintable.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsArg.tagnum = -1 ;
  G__G__RooStatsLN_RooArgSet.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsCollection.tagnum = -1 ;
  G__G__RooStatsLN_RooArgList.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_TTree.tagnum = -1 ;
  G__G__RooStatsLN_RooRealProxy.tagnum = -1 ;
  G__G__RooStatsLN_RooProdPdf.tagnum = -1 ;
  G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsReal.tagnum = -1 ;
  G__G__RooStatsLN_dequelERooAbsCachemUcOallocatorlERooAbsCachemUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooDataSet.tagnum = -1 ;
  G__G__RooStatsLN_maplERooAbsArgmUcOTRefArraymUcOlesslERooAbsArgmUgRcOallocatorlEpairlERooAbsArgmUsPconstcOTRefArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_dequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_stacklERooAbsArgmUcOdequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooCmdArg.tagnum = -1 ;
  G__G__RooStatsLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__RooStatsLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TH1.tagnum = -1 ;
  G__G__RooStatsLN_TH1F.tagnum = -1 ;
  G__G__RooStatsLN_TF1.tagnum = -1 ;
  G__G__RooStatsLN_TGraph.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_RooRealVar.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooCurvemUcOallocatorlERooCurvemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_listlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooDataHist.tagnum = -1 ;
  G__G__RooStatsLN_RooFitResult.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsPdf.tagnum = -1 ;
  G__G__RooStatsLN_RooCategory.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooPlot.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_pairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_dequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsPdfcLcLGenSpec.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETClassmUcOintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_pairlEstringcOintgR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsStudy.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsDatamUcOallocatorlERooAbsDatamUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_listlETObjectmUcOallocatorlETObjectmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_TRef.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLTestStatistic.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSamplingDistribution.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLTestStatSampler.tagnum = -1 ;
  G__G__RooStatsLN_listlERooDataSetmUcOallocatorlERooDataSetmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_ROOTcLcLMath.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator.tagnum = -1 ;
  G__G__RooStatsLN_ROOTcLcLMathcLcLIBaseFunctionOneDim.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLConfInterval.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLIntervalCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSimpleInterval.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLBayesianCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLBernsteinCorrection.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLCombinedCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup.tagnum = -1 ;
  G__G__RooStatsLN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLAcceptanceRegion.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSamplingSummary.tagnum = -1 ;
  G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLConfidenceBelt.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_TRandom.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLDebuggingSampler.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsStudymUcOallocatorlERooAbsStudymUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProofConfig.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLNuisanceParametersSampler.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLToyMCSampler.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_listlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsPdfcLcLGenSpecmUcOallocatorlERooAbsPdfcLcLGenSpecmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLDebuggingTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLPointSetInterval.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLFeldmanCousins.tagnum = -1 ;
  G__G__RooStatsLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLFrequentistCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHeaviside.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHLFactory.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHybridCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHybridPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHybridResult.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal.tagnum = -1 ;
  G__G__RooStatsLN_TLine.tagnum = -1 ;
  G__G__RooStatsLN_TLegend.tagnum = -1 ;
  G__G__RooStatsLN_TVirtualPad.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t.tagnum = -1 ;
  G__G__RooStatsLN_TGraphErrors.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInverter.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType.tagnum = -1 ;
  G__G__RooStatsLN_auto_ptrlETGraphErrorsgR.tagnum = -1 ;
  G__G__RooStatsLN_auto_ptrlERooStatscLcLHypoTestCalculatorGenericgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal.tagnum = -1 ;
  G__G__RooStatsLN_TMultiGraph.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSamplingDistPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooList.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLHypoTestPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLLikelihoodInterval.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR.tagnum = -1 ;
  G__G__RooStatsLN_auto_ptrlERooFunctorgR.tagnum = -1 ;
  G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot.tagnum = -1 ;
  G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooCacheManagerlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_THnSparse.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMarkovChain.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProposalFunction.tagnum = -1 ;
  G__G__RooStatsLN_RooNDKeysPdf.tagnum = -1 ;
  G__G__RooStatsLN_RooProduct.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMCMCInterval.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLdA.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMCMCCalculator.tagnum = -1 ;
  G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMetropolisHastings.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType.tagnum = -1 ;
  G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLMinNLLTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLNeymanConstruction.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLNumberCountingUtils.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLNumEventsTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLPdfProposal.tagnum = -1 ;
  G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProfileInspector.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLUniformProposal.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLProposalHelper.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSequentialProposal.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSPlot.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLSPlotcLcLdA.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLtoysStrategies.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler.tagnum = -1 ;
  G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLToyMCStudy.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLToyMCPayload.tagnum = -1 ;
  G__G__RooStatsLN_RooAbsMCStudyModule.tagnum = -1 ;
  G__G__RooStatsLN_listlERooAbsMCStudyModulemUcOallocatorlERooAbsMCStudyModulemUgRsPgR.tagnum = -1 ;
  G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__RooStats() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TString);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_ROOT);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_string);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TList);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsData);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooWorkspace);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStats),0,-1,0,(char*)NULL,G__setup_memvarRooStats,G__setup_memfuncRooStats);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestResult),sizeof(RooStats::HypoTestResult),-1,327424,"Base class to represent results of a hypothesis test",G__setup_memvarRooStatscLcLHypoTestResult,G__setup_memfuncRooStatscLcLHypoTestResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLModelConfig),sizeof(RooStats::ModelConfig),-1,323840,"A class that holds configuration information for a model using a workspace as a store",G__setup_memvarRooStatscLcLModelConfig,G__setup_memfuncRooStatscLcLModelConfig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculator),sizeof(RooStats::HypoTestCalculator),-1,263172,"Interface for tools doing hypothesis tests",G__setup_memvarRooStatscLcLHypoTestCalculator,G__setup_memfuncRooStatscLcLHypoTestCalculator);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TIterator);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooPrintable);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsArg);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooArgSet);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsCollection);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooArgList);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TTree);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooRealProxy);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooProdPdf);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_setlEpairlERooAbsArgmUcORooAbsArgmUgRcOlesslEpairlERooAbsArgmUcORooAbsArgmUgRsPgRcOallocatorlEpairlERooAbsArgmUcORooAbsArgmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsReal);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_dequelERooAbsCachemUcOallocatorlERooAbsCachemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooDataSet);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplERooAbsArgmUcOTRefArraymUcOlesslERooAbsArgmUgRcOallocatorlEpairlERooAbsArgmUsPconstcOTRefArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_dequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_stacklERooAbsArgmUcOdequelERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooCmdArg);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TF1);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TGraph);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooRealVar);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooCurvemUcOallocatorlERooCurvemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooCurvemUcOallocatorlERooCurvemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooDataHist);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooFitResult);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsPdf);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooCategory);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOTH1mUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTH1mUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcORooDataHistmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataHistmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcORooDataSetmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooDataSetmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcORooAbsDatamUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooAbsDatamUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooPlot);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_pairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEstringcOlistlERooAbsRealcLcLEvalErrorcOallocatorlERooAbsRealcLcLEvalErrorgRsPgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOallocatorlEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlongcOlesslEpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRsPgRcOallocatorlEpairlEconstsPpairlEconstsPRooArgSetmUcOconstsPRooArgSetmUgRcOunsignedsPlonggRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEintcOstringcOlesslEintgRcOallocatorlEpairlEconstsPintcOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_dequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_stacklEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOdequelEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRcOallocatorlEvectorlERooMsgServicecLcLStreamConfigcOallocatorlERooMsgServicecLcLStreamConfiggRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcObasic_ostreamlEcharcOchar_traitslEchargRsPgRmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooNormSetCachecOallocatorlERooNormSetCachegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsCacheElementmUcOallocatorlERooAbsCacheElementmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsPdfcLcLGenSpec);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETClassmUcOintcOlesslETClassmUgRcOallocatorlEpairlETClassmUsPconstcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOintcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_pairlEstringcOintgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcOintcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcORooExpensiveObjectCachecLcLExpensiveObjectmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooExpensiveObjectCachecLcLExpensiveObjectmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsStudy);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsDatamUcOallocatorlERooAbsDatamUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlETObjectmUcOallocatorlETObjectmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassRelInfocOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassRelInfogRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLClassFilescOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLClassFilesgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplETStringcORooWorkspacecLcLCodeRepocLcLExtraHeadercOlesslETStringgRcOallocatorlEpairlEconstsPTStringcORooWorkspacecLcLCodeRepocLcLExtraHeadergRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcORooArgSetcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooArgSetgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TRef);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLTestStatistic),sizeof(RooStats::TestStatistic),-1,263170,"Interface for a TestStatistic",G__setup_memvarRooStatscLcLTestStatistic,G__setup_memfuncRooStatscLcLTestStatistic);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSamplingDistribution),sizeof(RooStats::SamplingDistribution),-1,324864,"Class containing the results of the HybridCalculator",G__setup_memvarRooStatscLcLSamplingDistribution,G__setup_memfuncRooStatscLcLSamplingDistribution);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLTestStatSampler),sizeof(RooStats::TestStatSampler),-1,263183,"Interface for tools setting limits (producing confidence intervals)",G__setup_memvarRooStatscLcLTestStatSampler,G__setup_memfuncRooStatscLcLTestStatSampler);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooDataSetmUcOallocatorlERooDataSetmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_ROOTcLcLMath);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcORooSharedPropertiesmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcORooSharedPropertiesmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEintcOallocatorlEintgRsPgRcOallocatorlEvectorlEintcOallocatorlEintgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooArgSetmUcOallocatorlERooArgSetmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsRealmUcOallocatorlERooAbsRealmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestCalculatorGeneric),sizeof(RooStats::HypoTestCalculatorGeneric),-1,295936,(char*)NULL,G__setup_memvarRooStatscLcLHypoTestCalculatorGeneric,G__setup_memfuncRooStatscLcLHypoTestCalculatorGeneric);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLAsymptoticCalculator),sizeof(RooStats::AsymptoticCalculator),-1,295936,(char*)NULL,G__setup_memvarRooStatscLcLAsymptoticCalculator,G__setup_memfuncRooStatscLcLAsymptoticCalculator);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_ROOTcLcLMathcLcLIBaseFunctionOneDim);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLConfInterval),sizeof(RooStats::ConfInterval),-1,326917,"Interface for Confidence Intervals",G__setup_memvarRooStatscLcLConfInterval,G__setup_memfuncRooStatscLcLConfInterval);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLIntervalCalculator),sizeof(RooStats::IntervalCalculator),-1,263175,"Interface for tools setting limits (producing confidence intervals)",G__setup_memvarRooStatscLcLIntervalCalculator,G__setup_memfuncRooStatscLcLIntervalCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSimpleInterval),sizeof(RooStats::SimpleInterval),-1,326912,"Concrete implementation of ConfInterval for simple 1-D intervals in the form [a,b]",G__setup_memvarRooStatscLcLSimpleInterval,G__setup_memfuncRooStatscLcLSimpleInterval);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLBayesianCalculator),sizeof(RooStats::BayesianCalculator),-1,324864,"BayesianCalculator class",G__setup_memvarRooStatscLcLBayesianCalculator,G__setup_memfuncRooStatscLcLBayesianCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLBernsteinCorrection),sizeof(RooStats::BernsteinCorrection),-1,263424,"A utility to add polynomial corrrection terms to a model to improve the description of data.",G__setup_memvarRooStatscLcLBernsteinCorrection,G__setup_memfuncRooStatscLcLBernsteinCorrection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLCombinedCalculator),sizeof(RooStats::CombinedCalculator),-1,296195,"A base class that is for tools that can be both HypoTestCalculators and IntervalCalculators",G__setup_memvarRooStatscLcLCombinedCalculator,G__setup_memfuncRooStatscLcLCombinedCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSamplingSummaryLookup),sizeof(RooStats::SamplingSummaryLookup),-1,292096,"A simple class used by ConfidenceBelt",G__setup_memvarRooStatscLcLSamplingSummaryLookup,G__setup_memfuncRooStatscLcLSamplingSummaryLookup);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEintcOpairlEdoublecOdoublegRcOlesslEintgRcOallocatorlEpairlEconstsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLAcceptanceRegion),sizeof(RooStats::AcceptanceRegion),-1,324864,"A simple class for acceptance regions used for ConfidenceBelt",G__setup_memvarRooStatscLcLAcceptanceRegion,G__setup_memfuncRooStatscLcLAcceptanceRegion);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSamplingSummary),sizeof(RooStats::SamplingSummary),-1,324864,"A summary of acceptance regions for confidence belt",G__setup_memvarRooStatscLcLSamplingSummary,G__setup_memfuncRooStatscLcLSamplingSummary);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEintcORooStatscLcLAcceptanceRegioncOlesslEintgRcOallocatorlEpairlEconstsPintcORooStatscLcLAcceptanceRegiongRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLConfidenceBelt),sizeof(RooStats::ConfidenceBelt),-1,324864,"A confidence belt for the Neyman Construction",G__setup_memvarRooStatscLcLConfidenceBelt,G__setup_memfuncRooStatscLcLConfidenceBelt);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLSamplingSummarycOallocatorlERooStatscLcLSamplingSummarygRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TRandom);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLDebuggingSampler),sizeof(RooStats::DebuggingSampler),-1,263427,"A simple implementation of the DistributionCreator interface",G__setup_memvarRooStatscLcLDebuggingSampler,G__setup_memfuncRooStatscLcLDebuggingSampler);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsStudymUcOallocatorlERooAbsStudymUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProofConfig),sizeof(RooStats::ProofConfig),-1,295936,"Configuration options for proof.",G__setup_memvarRooStatscLcLProofConfig,G__setup_memfuncRooStatscLcLProofConfig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLDetailedOutputAggregator),sizeof(RooStats::DetailedOutputAggregator),-1,263424,(char*)NULL,G__setup_memvarRooStatscLcLDetailedOutputAggregator,G__setup_memfuncRooStatscLcLDetailedOutputAggregator);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLNuisanceParametersSampler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLToyMCSampler),sizeof(RooStats::ToyMCSampler),-1,296192,"A simple implementation of the TestStatSampler interface",G__setup_memvarRooStatscLcLToyMCSampler,G__setup_memfuncRooStatscLcLToyMCSampler);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooStatscLcLTestStatisticmUcOallocatorlERooStatscLcLTestStatisticmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooArgSetmUcOallocatorlERooArgSetmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsPdfcLcLGenSpecmUcOallocatorlERooAbsPdfcLcLGenSpecmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLDebuggingTestStat),sizeof(RooStats::DebuggingTestStat),-1,263425,"A concrete implementation of the TestStatistic interface, useful for debugging.",G__setup_memvarRooStatscLcLDebuggingTestStat,G__setup_memfuncRooStatscLcLDebuggingTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLPointSetInterval),sizeof(RooStats::PointSetInterval),-1,324864,"Concrete implementation of ConfInterval for simple 1-D intervals in the form [a,b]",G__setup_memvarRooStatscLcLPointSetInterval,G__setup_memfuncRooStatscLcLPointSetInterval);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLFeldmanCousins),sizeof(RooStats::FeldmanCousins),-1,295936,"Interface for tools setting limits (producing confidence intervals)",G__setup_memvarRooStatscLcLFeldmanCousins,G__setup_memfuncRooStatscLcLFeldmanCousins);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEpairlEstringcOintgRcOallocatorlEpairlEstringcOintgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLFrequentistCalculator),sizeof(RooStats::FrequentistCalculator),-1,295936,(char*)NULL,G__setup_memvarRooStatscLcLFrequentistCalculator,G__setup_memfuncRooStatscLcLFrequentistCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHeaviside),sizeof(RooStats::Heaviside),-1,325376,"Your description goes here...",G__setup_memvarRooStatscLcLHeaviside,G__setup_memfuncRooStatscLcLHeaviside);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHLFactory),sizeof(RooStats::HLFactory),-1,324864,"The high Level Model Factory to create models from datacards",G__setup_memvarRooStatscLcLHLFactory,G__setup_memfuncRooStatscLcLHLFactory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHybridCalculator),sizeof(RooStats::HybridCalculator),-1,295936,(char*)NULL,G__setup_memvarRooStatscLcLHybridCalculator,G__setup_memfuncRooStatscLcLHybridCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHybridPlot),sizeof(RooStats::HybridPlot),-1,324608,"Provides the plots for an HybridResult",G__setup_memvarRooStatscLcLHybridPlot,G__setup_memfuncRooStatscLcLHybridPlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHybridResult),sizeof(RooStats::HybridResult),-1,324864,"Class containing the results of the HybridCalculator",G__setup_memvarRooStatscLcLHybridResult,G__setup_memfuncRooStatscLcLHybridResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHybridCalculatorOriginal),sizeof(RooStats::HybridCalculatorOriginal),-1,324864,"Hypothesis test calculator using a Bayesian-frequentist hybrid method",G__setup_memvarRooStatscLcLHybridCalculatorOriginal,G__setup_memfuncRooStatscLcLHybridCalculatorOriginal);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TLine);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TLegend);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TVirtualPad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResult),sizeof(RooStats::HypoTestInverterResult),-1,326912,"HypoTestInverterResult class      ",G__setup_memvarRooStatscLcLHypoTestInverterResult,G__setup_memfuncRooStatscLcLHypoTestInverterResult);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterResultcLcLInterpolOption_t);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TGraphErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInverter),sizeof(RooStats::HypoTestInverter),-1,298752,"HypoTestInverter class",G__setup_memvarRooStatscLcLHypoTestInverter,G__setup_memfuncRooStatscLcLHypoTestInverter);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInvertercLcLECalculatorType);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_auto_ptrlETGraphErrorsgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_auto_ptrlERooStatscLcLHypoTestCalculatorGenericgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterOriginal),sizeof(RooStats::HypoTestInverterOriginal),-1,324864,"HypoTestInverterOriginal class",G__setup_memvarRooStatscLcLHypoTestInverterOriginal,G__setup_memfuncRooStatscLcLHypoTestInverterOriginal);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_TMultiGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSamplingDistPlot),sizeof(RooStats::SamplingDistPlot),-1,324864,"Class containing the results of the HybridCalculator",G__setup_memvarRooStatscLcLSamplingDistPlot,G__setup_memfuncRooStatscLcLSamplingDistPlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestInverterPlot),sizeof(RooStats::HypoTestInverterPlot),-1,324608,"HypoTestInverterPlot class",G__setup_memvarRooStatscLcLHypoTestInverterPlot,G__setup_memfuncRooStatscLcLHypoTestInverterPlot);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLHypoTestPlot),sizeof(RooStats::HypoTestPlot),-1,324864,(char*)NULL,G__setup_memvarRooStatscLcLHypoTestPlot,G__setup_memfuncRooStatscLcLHypoTestPlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLLikelihoodInterval),sizeof(RooStats::LikelihoodInterval),-1,324864,"Concrete implementation of a ConfInterval based on a likelihood ratio",G__setup_memvarRooStatscLcLLikelihoodInterval,G__setup_memfuncRooStatscLcLLikelihoodInterval);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOdoublecOlesslEstringgRcOallocatorlEpairlEconstsPstringcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_auto_ptrlERooFunctorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLLikelihoodIntervalPlot),sizeof(RooStats::LikelihoodIntervalPlot),-1,324864,"Class containing the results of the IntervalCalculator",G__setup_memvarRooStatscLcLLikelihoodIntervalPlot,G__setup_memfuncRooStatscLcLLikelihoodIntervalPlot);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEconstsPRooAbsArgmUcOpairlEdoublecOdoublegRcOlesslEconstsPRooAbsArgmUgRcOallocatorlEpairlEconstsPRooAbsArgmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooCacheManagerlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsLValuemUcOallocatorlERooAbsLValuemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooAbsBinningmUcOallocatorlEconstsPRooAbsBinningmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_THnSparse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMarkovChain),sizeof(RooStats::MarkovChain),-1,324864,(char*)NULL,G__setup_memvarRooStatscLcLMarkovChain,G__setup_memfuncRooStatscLcLMarkovChain);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooFitcLcLMPSplitcOallocatorlERooFitcLcLMPSplitgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsArgmUcOallocatorlERooAbsArgmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMaxLikelihoodEstimateTestStat),sizeof(RooStats::MaxLikelihoodEstimateTestStat),-1,295168,(char*)NULL,G__setup_memvarRooStatscLcLMaxLikelihoodEstimateTestStat,G__setup_memfuncRooStatscLcLMaxLikelihoodEstimateTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProposalFunction),sizeof(RooStats::ProposalFunction),-1,292099,"Interface for the proposal function used with Markov Chain Monte Carlo",G__setup_memvarRooStatscLcLProposalFunction,G__setup_memfuncRooStatscLcLProposalFunction);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooNDKeysPdf);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooProduct);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMCMCInterval),sizeof(RooStats::MCMCInterval),-1,324864,"Concrete implementation of a ConfInterval based on MCMC calculation",G__setup_memvarRooStatscLcLMCMCInterval,G__setup_memfuncRooStatscLcLMCMCInterval);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalcLcLIntervalType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMCMCCalculator),sizeof(RooStats::MCMCCalculator),-1,324864,"Markov Chain Monte Carlo calculator for Bayesian credible intervals",G__setup_memvarRooStatscLcLMCMCCalculator,G__setup_memfuncRooStatscLcLMCMCCalculator);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEintcOboolcOlesslEintgRcOallocatorlEpairlEconstsPintcOboolgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlETVectorTlEdoublegRcOallocatorlETVectorTlEdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUcOlesslEpairlEstringcOintgRsPgRcOallocatorlEpairlEconstsPpairlEstringcOintgRcORooNDKeysPdfcLcLBoxInfomUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMCMCIntervalPlot),sizeof(RooStats::MCMCIntervalPlot),-1,324864,"Class containing the results of the MCMCCalculator",G__setup_memvarRooStatscLcLMCMCIntervalPlot,G__setup_memfuncRooStatscLcLMCMCIntervalPlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMetropolisHastings),sizeof(RooStats::MetropolisHastings),-1,324864,"Markov Chain Monte Carlo calculator for Bayesian credible intervals",G__setup_memvarRooStatscLcLMetropolisHastings,G__setup_memfuncRooStatscLcLMetropolisHastings);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionSign);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMetropolisHastingscLcLFunctionType);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStat),sizeof(RooStats::ProfileLikelihoodTestStat),-1,296192,"implements the profile likelihood ratio as a test statistic to be used with several tools",G__setup_memvarRooStatscLcLProfileLikelihoodTestStat,G__setup_memfuncRooStatscLcLProfileLikelihoodTestStat);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodTestStatcLcLLimitType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLMinNLLTestStat),sizeof(RooStats::MinNLLTestStat),-1,298752,"implements the minimum NLL as a test statistic to be used with several tools",G__setup_memvarRooStatscLcLMinNLLTestStat,G__setup_memfuncRooStatscLcLMinNLLTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLNeymanConstruction),sizeof(RooStats::NeymanConstruction),-1,295936,"Interface for tools setting limits (producing confidence intervals)",G__setup_memvarRooStatscLcLNeymanConstruction,G__setup_memfuncRooStatscLcLNeymanConstruction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLNumberCountingPdfFactory),sizeof(RooStats::NumberCountingPdfFactory),-1,263424,"A factory specific to common number counting problems.",G__setup_memvarRooStatscLcLNumberCountingPdfFactory,G__setup_memfuncRooStatscLcLNumberCountingPdfFactory);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLNumberCountingUtils),0,-1,0,(char*)NULL,G__setup_memvarRooStatscLcLNumberCountingUtils,G__setup_memfuncRooStatscLcLNumberCountingUtils);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLNumEventsTestStat),sizeof(RooStats::NumEventsTestStat),-1,296192,(char*)NULL,G__setup_memvarRooStatscLcLNumEventsTestStat,G__setup_memfuncRooStatscLcLNumEventsTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLPdfProposal),sizeof(RooStats::PdfProposal),-1,324864,(char*)NULL,G__setup_memvarRooStatscLcLPdfProposal,G__setup_memfuncRooStatscLcLPdfProposal);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_maplERooRealVarmUcORooAbsRealmUcOlesslERooRealVarmUgRcOallocatorlEpairlERooRealVarmUsPconstcORooAbsRealmUgRsPgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProfileInspector),sizeof(RooStats::ProfileInspector),-1,263424,"Class containing the results of the IntervalCalculator",G__setup_memvarRooStatscLcLProfileInspector,G__setup_memfuncRooStatscLcLProfileInspector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProfileLikelihoodCalculator),sizeof(RooStats::ProfileLikelihoodCalculator),-1,296192,"A concrete implementation of CombinedCalculator that uses the ProfileLikelihood ratio.",G__setup_memvarRooStatscLcLProfileLikelihoodCalculator,G__setup_memfuncRooStatscLcLProfileLikelihoodCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLUniformProposal),sizeof(RooStats::UniformProposal),-1,292096,"A concrete implementation of ProposalFunction, that uniformly samples the parameter space.",G__setup_memvarRooStatscLcLUniformProposal,G__setup_memfuncRooStatscLcLUniformProposal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLProposalHelper),sizeof(RooStats::ProposalHelper),-1,292096,(char*)NULL,G__setup_memvarRooStatscLcLProposalHelper,G__setup_memfuncRooStatscLcLProposalHelper);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLRatioOfProfiledLikelihoodsTestStat),sizeof(RooStats::RatioOfProfiledLikelihoodsTestStat),-1,296192,"implements the ratio of profiled likelihood as test statistic",G__setup_memvarRooStatscLcLRatioOfProfiledLikelihoodsTestStat,G__setup_memfuncRooStatscLcLRatioOfProfiledLikelihoodsTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSequentialProposal),sizeof(RooStats::SequentialProposal),-1,324864,"A concrete implementation of ProposalFunction, that uniformly samples the parameter space.",G__setup_memvarRooStatscLcLSequentialProposal,G__setup_memfuncRooStatscLcLSequentialProposal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSimpleLikelihoodRatioTestStat),sizeof(RooStats::SimpleLikelihoodRatioTestStat),-1,296192,(char*)NULL,G__setup_memvarRooStatscLcLSimpleLikelihoodRatioTestStat,G__setup_memfuncRooStatscLcLSimpleLikelihoodRatioTestStat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSPlot),sizeof(RooStats::SPlot),-1,325376,"Class used for making sPlots",G__setup_memvarRooStatscLcLSPlot,G__setup_memfuncRooStatscLcLSPlot);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLSPlotcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLtoysStrategies);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLToyMCImportanceSampler),sizeof(RooStats::ToyMCImportanceSampler),-1,296192,"An implementation of importance sampling",G__setup_memvarRooStatscLcLToyMCImportanceSampler,G__setup_memfuncRooStatscLcLToyMCImportanceSampler);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlERooAbsPdfmUcOallocatorlERooAbsPdfmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_vectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_reverse_iteratorlEvectorlEconstsPRooArgSetmUcOallocatorlEconstsPRooArgSetmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLToyMCStudy),sizeof(RooStats::ToyMCStudy),-1,324864,"toy MC study for parallel processing",G__setup_memvarRooStatscLcLToyMCStudy,G__setup_memfuncRooStatscLcLToyMCStudy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLToyMCPayload),sizeof(RooStats::ToyMCPayload),-1,324864,(char*)NULL,G__setup_memvarRooStatscLcLToyMCPayload,G__setup_memfuncRooStatscLcLToyMCPayload);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooAbsMCStudyModule);
   G__get_linked_tagnum_fwd(&G__G__RooStatsLN_listlERooAbsMCStudyModulemUcOallocatorlERooAbsMCStudyModulemUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__RooStatsLN_RooStatscLcLUpperLimitMCSModule),sizeof(RooStats::UpperLimitMCSModule),-1,325120,"MCStudy module to calculate upperlimit of a given poi",G__setup_memvarRooStatscLcLUpperLimitMCSModule,G__setup_memfuncRooStatscLcLUpperLimitMCSModule);
}
extern "C" void G__cpp_setupG__RooStats(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__RooStats()");
  G__set_cpp_environmentG__RooStats();
  G__cpp_setup_tagtableG__RooStats();

  G__cpp_setup_inheritanceG__RooStats();

  G__cpp_setup_typetableG__RooStats();

  G__cpp_setup_memvarG__RooStats();

  G__cpp_setup_memfuncG__RooStats();
  G__cpp_setup_globalG__RooStats();
  G__cpp_setup_funcG__RooStats();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__RooStats();
  return;
}
class G__cpp_setup_initG__RooStats {
  public:
    G__cpp_setup_initG__RooStats() { G__add_setup_func("G__RooStats",(G__incsetup)(&G__cpp_setupG__RooStats)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__RooStats() { G__remove_setup_func("G__RooStats"); }
};
G__cpp_setup_initG__RooStats G__cpp_setup_initializerG__RooStats;