libBAT_rdict.cxx

//
// File generated by /usr/bin/rootcint at Fri May 18 12:41:28 2018

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

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

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

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

// START OF SHADOWS

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

namespace ROOTDict {
   void BCHistogramBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCHistogramBase_Dictionary();
   static void *new_BCHistogramBase(void *p = 0);
   static void *newArray_BCHistogramBase(Long_t size, void *p);
   static void delete_BCHistogramBase(void *p);
   static void deleteArray_BCHistogramBase(void *p);
   static void destruct_BCHistogramBase(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCHistogramBase*)
   {
      ::BCHistogramBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCHistogramBase),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCHistogramBase", "./.includes/BAT/BCHistogramBase.h", 34,
                  typeid(::BCHistogramBase), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCHistogramBase_Dictionary, isa_proxy, 1,
                  sizeof(::BCHistogramBase) );
      instance.SetNew(&new_BCHistogramBase);
      instance.SetNewArray(&newArray_BCHistogramBase);
      instance.SetDelete(&delete_BCHistogramBase);
      instance.SetDeleteArray(&deleteArray_BCHistogramBase);
      instance.SetDestructor(&destruct_BCHistogramBase);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCHistogramBase*)
   {
      return GenerateInitInstanceLocal((::BCHistogramBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCHistogramBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCLog_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCLog_Dictionary();
   static void *new_BCLog(void *p = 0);
   static void *newArray_BCLog(Long_t size, void *p);
   static void delete_BCLog(void *p);
   static void deleteArray_BCLog(void *p);
   static void destruct_BCLog(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCLog*)
   {
      ::BCLog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCLog),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCLog", "./.includes/BAT/BCLog.h", 52,
                  typeid(::BCLog), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCLog_Dictionary, isa_proxy, 1,
                  sizeof(::BCLog) );
      instance.SetNew(&new_BCLog);
      instance.SetNewArray(&newArray_BCLog);
      instance.SetDelete(&delete_BCLog);
      instance.SetDeleteArray(&deleteArray_BCLog);
      instance.SetDestructor(&destruct_BCLog);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCLog*)
   {
      return GenerateInitInstanceLocal((::BCLog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCLog*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace BCMath {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void BCMath_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("BCMath", 0 /*version*/, "./.includes/BAT/BCMath.h", 33,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &BCMath_Dictionary, 1);
         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 BCMath_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOTDict {
   void BCVariable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCVariable_Dictionary();
   static void *new_BCVariable(void *p = 0);
   static void *newArray_BCVariable(Long_t size, void *p);
   static void delete_BCVariable(void *p);
   static void deleteArray_BCVariable(void *p);
   static void destruct_BCVariable(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCVariable*)
   {
      ::BCVariable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCVariable),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCVariable", "./.includes/BAT/BCVariable.h", 36,
                  typeid(::BCVariable), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCVariable_Dictionary, isa_proxy, 1,
                  sizeof(::BCVariable) );
      instance.SetNew(&new_BCVariable);
      instance.SetNewArray(&newArray_BCVariable);
      instance.SetDelete(&delete_BCVariable);
      instance.SetDeleteArray(&deleteArray_BCVariable);
      instance.SetDestructor(&destruct_BCVariable);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCVariable*)
   {
      return GenerateInitInstanceLocal((::BCVariable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCVariable*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCDataPoint_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCDataPoint_Dictionary();
   static void *new_BCDataPoint(void *p = 0);
   static void *newArray_BCDataPoint(Long_t size, void *p);
   static void delete_BCDataPoint(void *p);
   static void deleteArray_BCDataPoint(void *p);
   static void destruct_BCDataPoint(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCDataPoint*)
   {
      ::BCDataPoint *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCDataPoint),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCDataPoint", "./.includes/BAT/BCDataPoint.h", 35,
                  typeid(::BCDataPoint), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCDataPoint_Dictionary, isa_proxy, 1,
                  sizeof(::BCDataPoint) );
      instance.SetNew(&new_BCDataPoint);
      instance.SetNewArray(&newArray_BCDataPoint);
      instance.SetDelete(&delete_BCDataPoint);
      instance.SetDeleteArray(&deleteArray_BCDataPoint);
      instance.SetDestructor(&destruct_BCDataPoint);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCDataPoint*)
   {
      return GenerateInitInstanceLocal((::BCDataPoint*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCDataPoint*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCDataSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCDataSet_Dictionary();
   static void *new_BCDataSet(void *p = 0);
   static void *newArray_BCDataSet(Long_t size, void *p);
   static void delete_BCDataSet(void *p);
   static void deleteArray_BCDataSet(void *p);
   static void destruct_BCDataSet(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCDataSet*)
   {
      ::BCDataSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCDataSet),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCDataSet", "./.includes/BAT/BCDataSet.h", 40,
                  typeid(::BCDataSet), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCDataSet_Dictionary, isa_proxy, 1,
                  sizeof(::BCDataSet) );
      instance.SetNew(&new_BCDataSet);
      instance.SetNewArray(&newArray_BCDataSet);
      instance.SetDelete(&delete_BCDataSet);
      instance.SetDeleteArray(&deleteArray_BCDataSet);
      instance.SetDestructor(&destruct_BCDataSet);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCDataSet*)
   {
      return GenerateInitInstanceLocal((::BCDataSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCDataSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCH1D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCH1D_Dictionary();
   static void *new_BCH1D(void *p = 0);
   static void *newArray_BCH1D(Long_t size, void *p);
   static void delete_BCH1D(void *p);
   static void deleteArray_BCH1D(void *p);
   static void destruct_BCH1D(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCH1D*)
   {
      ::BCH1D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCH1D),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCH1D", "./.includes/BAT/BCH1D.h", 35,
                  typeid(::BCH1D), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCH1D_Dictionary, isa_proxy, 1,
                  sizeof(::BCH1D) );
      instance.SetNew(&new_BCH1D);
      instance.SetNewArray(&newArray_BCH1D);
      instance.SetDelete(&delete_BCH1D);
      instance.SetDeleteArray(&deleteArray_BCH1D);
      instance.SetDestructor(&destruct_BCH1D);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCH1D*)
   {
      return GenerateInitInstanceLocal((::BCH1D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCH1D*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCH2D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCH2D_Dictionary();
   static void *new_BCH2D(void *p = 0);
   static void *newArray_BCH2D(Long_t size, void *p);
   static void delete_BCH2D(void *p);
   static void deleteArray_BCH2D(void *p);
   static void destruct_BCH2D(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCH2D*)
   {
      ::BCH2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCH2D),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCH2D", "./.includes/BAT/BCH2D.h", 38,
                  typeid(::BCH2D), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCH2D_Dictionary, isa_proxy, 1,
                  sizeof(::BCH2D) );
      instance.SetNew(&new_BCH2D);
      instance.SetNewArray(&newArray_BCH2D);
      instance.SetDelete(&delete_BCH2D);
      instance.SetDeleteArray(&deleteArray_BCH2D);
      instance.SetDestructor(&destruct_BCH2D);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCH2D*)
   {
      return GenerateInitInstanceLocal((::BCH2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCH2D*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCPrior_Dictionary();
   static void delete_BCPrior(void *p);
   static void deleteArray_BCPrior(void *p);
   static void destruct_BCPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCPrior*)
   {
      ::BCPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCPrior", "./.includes/BAT/BCPrior.h", 50,
                  typeid(::BCPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCPrior) );
      instance.SetDelete(&delete_BCPrior);
      instance.SetDeleteArray(&deleteArray_BCPrior);
      instance.SetDestructor(&destruct_BCPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCPrior*)
   {
      return GenerateInitInstanceLocal((::BCPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCParameter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCParameter_Dictionary();
   static void *new_BCParameter(void *p = 0);
   static void *newArray_BCParameter(Long_t size, void *p);
   static void delete_BCParameter(void *p);
   static void deleteArray_BCParameter(void *p);
   static void destruct_BCParameter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCParameter*)
   {
      ::BCParameter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCParameter),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCParameter", "./.includes/BAT/BCParameter.h", 35,
                  typeid(::BCParameter), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCParameter_Dictionary, isa_proxy, 1,
                  sizeof(::BCParameter) );
      instance.SetNew(&new_BCParameter);
      instance.SetNewArray(&newArray_BCParameter);
      instance.SetDelete(&delete_BCParameter);
      instance.SetDeleteArray(&deleteArray_BCParameter);
      instance.SetDestructor(&destruct_BCParameter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCParameter*)
   {
      return GenerateInitInstanceLocal((::BCParameter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCParameter*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace BCAux {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void BCAux_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("BCAux", 0 /*version*/, "./.includes/BAT/BCAux.h", 37,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &BCAux_Dictionary, 1);
         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 BCAux_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOTDict {
   void BCConstantPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCConstantPrior_Dictionary();
   static void *new_BCConstantPrior(void *p = 0);
   static void *newArray_BCConstantPrior(Long_t size, void *p);
   static void delete_BCConstantPrior(void *p);
   static void deleteArray_BCConstantPrior(void *p);
   static void destruct_BCConstantPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCConstantPrior*)
   {
      ::BCConstantPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCConstantPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCConstantPrior", "./.includes/BAT/BCConstantPrior.h", 34,
                  typeid(::BCConstantPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCConstantPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCConstantPrior) );
      instance.SetNew(&new_BCConstantPrior);
      instance.SetNewArray(&newArray_BCConstantPrior);
      instance.SetDelete(&delete_BCConstantPrior);
      instance.SetDeleteArray(&deleteArray_BCConstantPrior);
      instance.SetDestructor(&destruct_BCConstantPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCConstantPrior*)
   {
      return GenerateInitInstanceLocal((::BCConstantPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCConstantPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCGaussianPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCGaussianPrior_Dictionary();
   static void delete_BCGaussianPrior(void *p);
   static void deleteArray_BCGaussianPrior(void *p);
   static void destruct_BCGaussianPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCGaussianPrior*)
   {
      ::BCGaussianPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCGaussianPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCGaussianPrior", "./.includes/BAT/BCGaussianPrior.h", 34,
                  typeid(::BCGaussianPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCGaussianPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCGaussianPrior) );
      instance.SetDelete(&delete_BCGaussianPrior);
      instance.SetDeleteArray(&deleteArray_BCGaussianPrior);
      instance.SetDestructor(&destruct_BCGaussianPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCGaussianPrior*)
   {
      return GenerateInitInstanceLocal((::BCGaussianPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCGaussianPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCSplitGaussianPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCSplitGaussianPrior_Dictionary();
   static void delete_BCSplitGaussianPrior(void *p);
   static void deleteArray_BCSplitGaussianPrior(void *p);
   static void destruct_BCSplitGaussianPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCSplitGaussianPrior*)
   {
      ::BCSplitGaussianPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCSplitGaussianPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCSplitGaussianPrior", "./.includes/BAT/BCSplitGaussianPrior.h", 33,
                  typeid(::BCSplitGaussianPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCSplitGaussianPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCSplitGaussianPrior) );
      instance.SetDelete(&delete_BCSplitGaussianPrior);
      instance.SetDeleteArray(&deleteArray_BCSplitGaussianPrior);
      instance.SetDestructor(&destruct_BCSplitGaussianPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCSplitGaussianPrior*)
   {
      return GenerateInitInstanceLocal((::BCSplitGaussianPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCSplitGaussianPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCCauchyPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCCauchyPrior_Dictionary();
   static void delete_BCCauchyPrior(void *p);
   static void deleteArray_BCCauchyPrior(void *p);
   static void destruct_BCCauchyPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCCauchyPrior*)
   {
      ::BCCauchyPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCCauchyPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCCauchyPrior", "./.includes/BAT/BCCauchyPrior.h", 33,
                  typeid(::BCCauchyPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCCauchyPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCCauchyPrior) );
      instance.SetDelete(&delete_BCCauchyPrior);
      instance.SetDeleteArray(&deleteArray_BCCauchyPrior);
      instance.SetDestructor(&destruct_BCCauchyPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCCauchyPrior*)
   {
      return GenerateInitInstanceLocal((::BCCauchyPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCCauchyPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCObservable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCObservable_Dictionary();
   static void *new_BCObservable(void *p = 0);
   static void *newArray_BCObservable(Long_t size, void *p);
   static void delete_BCObservable(void *p);
   static void deleteArray_BCObservable(void *p);
   static void destruct_BCObservable(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCObservable*)
   {
      ::BCObservable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCObservable),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCObservable", "./.includes/BAT/BCObservable.h", 33,
                  typeid(::BCObservable), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCObservable_Dictionary, isa_proxy, 1,
                  sizeof(::BCObservable) );
      instance.SetNew(&new_BCObservable);
      instance.SetNewArray(&newArray_BCObservable);
      instance.SetDelete(&delete_BCObservable);
      instance.SetDeleteArray(&deleteArray_BCObservable);
      instance.SetDestructor(&destruct_BCObservable);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCObservable*)
   {
      return GenerateInitInstanceLocal((::BCObservable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCObservable*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCVariableSetlEBCObservablegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCVariableSetlEBCObservablegR_Dictionary();
   static void *new_BCVariableSetlEBCObservablegR(void *p = 0);
   static void *newArray_BCVariableSetlEBCObservablegR(Long_t size, void *p);
   static void delete_BCVariableSetlEBCObservablegR(void *p);
   static void deleteArray_BCVariableSetlEBCObservablegR(void *p);
   static void destruct_BCVariableSetlEBCObservablegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCVariableSet<BCObservable>*)
   {
      ::BCVariableSet<BCObservable> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCVariableSet<BCObservable>),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCVariableSet<BCObservable>", "./.includes/BAT/BCVariableSet.h", 36,
                  typeid(::BCVariableSet<BCObservable>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCVariableSetlEBCObservablegR_Dictionary, isa_proxy, 1,
                  sizeof(::BCVariableSet<BCObservable>) );
      instance.SetNew(&new_BCVariableSetlEBCObservablegR);
      instance.SetNewArray(&newArray_BCVariableSetlEBCObservablegR);
      instance.SetDelete(&delete_BCVariableSetlEBCObservablegR);
      instance.SetDeleteArray(&deleteArray_BCVariableSetlEBCObservablegR);
      instance.SetDestructor(&destruct_BCVariableSetlEBCObservablegR);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCVariableSet<BCObservable>*)
   {
      return GenerateInitInstanceLocal((::BCVariableSet<BCObservable>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCVariableSet<BCObservable>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void BCVariableSetlEBCObservablegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::BCVariableSet<BCObservable>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCTF1Prior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCTF1Prior_Dictionary();
   static void delete_BCTF1Prior(void *p);
   static void deleteArray_BCTF1Prior(void *p);
   static void destruct_BCTF1Prior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCTF1Prior*)
   {
      ::BCTF1Prior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCTF1Prior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCTF1Prior", "./.includes/BAT/BCTF1Prior.h", 33,
                  typeid(::BCTF1Prior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCTF1Prior_Dictionary, isa_proxy, 1,
                  sizeof(::BCTF1Prior) );
      instance.SetDelete(&delete_BCTF1Prior);
      instance.SetDeleteArray(&deleteArray_BCTF1Prior);
      instance.SetDestructor(&destruct_BCTF1Prior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCTF1Prior*)
   {
      return GenerateInitInstanceLocal((::BCTF1Prior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCTF1Prior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCTF1LogPrior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCTF1LogPrior_Dictionary();
   static void delete_BCTF1LogPrior(void *p);
   static void deleteArray_BCTF1LogPrior(void *p);
   static void destruct_BCTF1LogPrior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCTF1LogPrior*)
   {
      ::BCTF1LogPrior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCTF1LogPrior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCTF1LogPrior", "./.includes/BAT/BCTF1LogPrior.h", 33,
                  typeid(::BCTF1LogPrior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCTF1LogPrior_Dictionary, isa_proxy, 1,
                  sizeof(::BCTF1LogPrior) );
      instance.SetDelete(&delete_BCTF1LogPrior);
      instance.SetDeleteArray(&deleteArray_BCTF1LogPrior);
      instance.SetDestructor(&destruct_BCTF1LogPrior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCTF1LogPrior*)
   {
      return GenerateInitInstanceLocal((::BCTF1LogPrior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCTF1LogPrior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCTH1Prior_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCTH1Prior_Dictionary();
   static void delete_BCTH1Prior(void *p);
   static void deleteArray_BCTH1Prior(void *p);
   static void destruct_BCTH1Prior(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCTH1Prior*)
   {
      ::BCTH1Prior *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCTH1Prior),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCTH1Prior", "./.includes/BAT/BCTH1Prior.h", 31,
                  typeid(::BCTH1Prior), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCTH1Prior_Dictionary, isa_proxy, 1,
                  sizeof(::BCTH1Prior) );
      instance.SetDelete(&delete_BCTH1Prior);
      instance.SetDeleteArray(&deleteArray_BCTH1Prior);
      instance.SetDestructor(&destruct_BCTH1Prior);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCTH1Prior*)
   {
      return GenerateInitInstanceLocal((::BCTH1Prior*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCTH1Prior*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCParameterSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCParameterSet_Dictionary();
   static void *new_BCParameterSet(void *p = 0);
   static void *newArray_BCParameterSet(Long_t size, void *p);
   static void delete_BCParameterSet(void *p);
   static void deleteArray_BCParameterSet(void *p);
   static void destruct_BCParameterSet(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCParameterSet*)
   {
      ::BCParameterSet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCParameterSet),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCParameterSet", "./.includes/BAT/BCParameterSet.h", 31,
                  typeid(::BCParameterSet), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCParameterSet_Dictionary, isa_proxy, 1,
                  sizeof(::BCParameterSet) );
      instance.SetNew(&new_BCParameterSet);
      instance.SetNewArray(&newArray_BCParameterSet);
      instance.SetDelete(&delete_BCParameterSet);
      instance.SetDeleteArray(&deleteArray_BCParameterSet);
      instance.SetDestructor(&destruct_BCParameterSet);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCParameterSet*)
   {
      return GenerateInitInstanceLocal((::BCParameterSet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCParameterSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCEngineMCMC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCEngineMCMC_Dictionary();
   static void delete_BCEngineMCMC(void *p);
   static void deleteArray_BCEngineMCMC(void *p);
   static void destruct_BCEngineMCMC(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCEngineMCMC*)
   {
      ::BCEngineMCMC *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCEngineMCMC),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCEngineMCMC", "./.includes/BAT/BCEngineMCMC.h", 56,
                  typeid(::BCEngineMCMC), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCEngineMCMC_Dictionary, isa_proxy, 1,
                  sizeof(::BCEngineMCMC) );
      instance.SetDelete(&delete_BCEngineMCMC);
      instance.SetDeleteArray(&deleteArray_BCEngineMCMC);
      instance.SetDestructor(&destruct_BCEngineMCMC);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCEngineMCMC*)
   {
      return GenerateInitInstanceLocal((::BCEngineMCMC*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCEngineMCMC*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCModel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCModel_Dictionary();
   static void delete_BCModel(void *p);
   static void deleteArray_BCModel(void *p);
   static void destruct_BCModel(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCModel*)
   {
      ::BCModel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCModel),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCModel", "./.includes/BAT/BCModel.h", 40,
                  typeid(::BCModel), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCModel_Dictionary, isa_proxy, 1,
                  sizeof(::BCModel) );
      instance.SetDelete(&delete_BCModel);
      instance.SetDeleteArray(&deleteArray_BCModel);
      instance.SetDestructor(&destruct_BCModel);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCModel*)
   {
      return GenerateInitInstanceLocal((::BCModel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCIntegrate_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCIntegrate_Dictionary();
   static void delete_BCIntegrate(void *p);
   static void deleteArray_BCIntegrate(void *p);
   static void destruct_BCIntegrate(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCIntegrate*)
   {
      ::BCIntegrate *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCIntegrate),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCIntegrate", "./.includes/BAT/BCIntegrate.h", 144,
                  typeid(::BCIntegrate), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCIntegrate_Dictionary, isa_proxy, 1,
                  sizeof(::BCIntegrate) );
      instance.SetDelete(&delete_BCIntegrate);
      instance.SetDeleteArray(&deleteArray_BCIntegrate);
      instance.SetDestructor(&destruct_BCIntegrate);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCIntegrate*)
   {
      return GenerateInitInstanceLocal((::BCIntegrate*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCIntegrate*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCPriorModel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCPriorModel_Dictionary();
   static void delete_BCPriorModel(void *p);
   static void deleteArray_BCPriorModel(void *p);
   static void destruct_BCPriorModel(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCPriorModel*)
   {
      ::BCPriorModel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCPriorModel),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCPriorModel", "./.includes/BAT/BCPriorModel.h", 31,
                  typeid(::BCPriorModel), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCPriorModel_Dictionary, isa_proxy, 1,
                  sizeof(::BCPriorModel) );
      instance.SetDelete(&delete_BCPriorModel);
      instance.SetDeleteArray(&deleteArray_BCPriorModel);
      instance.SetDestructor(&destruct_BCPriorModel);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCPriorModel*)
   {
      return GenerateInitInstanceLocal((::BCPriorModel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCPriorModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCEmptyModel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCEmptyModel_Dictionary();
   static void *new_BCEmptyModel(void *p = 0);
   static void *newArray_BCEmptyModel(Long_t size, void *p);
   static void delete_BCEmptyModel(void *p);
   static void deleteArray_BCEmptyModel(void *p);
   static void destruct_BCEmptyModel(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCEmptyModel*)
   {
      ::BCEmptyModel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCEmptyModel),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCEmptyModel", "./.includes/BAT/BCEmptyModel.h", 30,
                  typeid(::BCEmptyModel), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCEmptyModel_Dictionary, isa_proxy, 1,
                  sizeof(::BCEmptyModel) );
      instance.SetNew(&new_BCEmptyModel);
      instance.SetNewArray(&newArray_BCEmptyModel);
      instance.SetDelete(&delete_BCEmptyModel);
      instance.SetDeleteArray(&deleteArray_BCEmptyModel);
      instance.SetDestructor(&destruct_BCEmptyModel);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCEmptyModel*)
   {
      return GenerateInitInstanceLocal((::BCEmptyModel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCEmptyModel*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void BCModelManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void BCModelManager_Dictionary();
   static void *new_BCModelManager(void *p = 0);
   static void *newArray_BCModelManager(Long_t size, void *p);
   static void delete_BCModelManager(void *p);
   static void deleteArray_BCModelManager(void *p);
   static void destruct_BCModelManager(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::BCModelManager*)
   {
      ::BCModelManager *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::BCModelManager),0);
      static ::ROOT::TGenericClassInfo 
         instance("BCModelManager", "./.includes/BAT/BCModelManager.h", 35,
                  typeid(::BCModelManager), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &BCModelManager_Dictionary, isa_proxy, 1,
                  sizeof(::BCModelManager) );
      instance.SetNew(&new_BCModelManager);
      instance.SetNewArray(&newArray_BCModelManager);
      instance.SetDelete(&delete_BCModelManager);
      instance.SetDeleteArray(&deleteArray_BCModelManager);
      instance.SetDestructor(&destruct_BCModelManager);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::BCModelManager*)
   {
      return GenerateInitInstanceLocal((::BCModelManager*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::BCModelManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCCauchyPrior(void *p) {
      delete ((::BCCauchyPrior*)p);
   }
   static void deleteArray_BCCauchyPrior(void *p) {
      delete [] ((::BCCauchyPrior*)p);
   }
   static void destruct_BCCauchyPrior(void *p) {
      typedef ::BCCauchyPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCCauchyPrior

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCConstantPrior(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCConstantPrior : new ::BCConstantPrior;
   }
   static void *newArray_BCConstantPrior(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCConstantPrior[nElements] : new ::BCConstantPrior[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCConstantPrior(void *p) {
      delete ((::BCConstantPrior*)p);
   }
   static void deleteArray_BCConstantPrior(void *p) {
      delete [] ((::BCConstantPrior*)p);
   }
   static void destruct_BCConstantPrior(void *p) {
      typedef ::BCConstantPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCConstantPrior

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCDataPoint(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCDataPoint : new ::BCDataPoint;
   }
   static void *newArray_BCDataPoint(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCDataPoint[nElements] : new ::BCDataPoint[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCDataPoint(void *p) {
      delete ((::BCDataPoint*)p);
   }
   static void deleteArray_BCDataPoint(void *p) {
      delete [] ((::BCDataPoint*)p);
   }
   static void destruct_BCDataPoint(void *p) {
      typedef ::BCDataPoint current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCDataPoint

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCDataSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCDataSet : new ::BCDataSet;
   }
   static void *newArray_BCDataSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCDataSet[nElements] : new ::BCDataSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCDataSet(void *p) {
      delete ((::BCDataSet*)p);
   }
   static void deleteArray_BCDataSet(void *p) {
      delete [] ((::BCDataSet*)p);
   }
   static void destruct_BCDataSet(void *p) {
      typedef ::BCDataSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCDataSet

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCEmptyModel(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCEmptyModel : new ::BCEmptyModel;
   }
   static void *newArray_BCEmptyModel(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCEmptyModel[nElements] : new ::BCEmptyModel[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCEmptyModel(void *p) {
      delete ((::BCEmptyModel*)p);
   }
   static void deleteArray_BCEmptyModel(void *p) {
      delete [] ((::BCEmptyModel*)p);
   }
   static void destruct_BCEmptyModel(void *p) {
      typedef ::BCEmptyModel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCEmptyModel

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCEngineMCMC(void *p) {
      delete ((::BCEngineMCMC*)p);
   }
   static void deleteArray_BCEngineMCMC(void *p) {
      delete [] ((::BCEngineMCMC*)p);
   }
   static void destruct_BCEngineMCMC(void *p) {
      typedef ::BCEngineMCMC current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCEngineMCMC

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCGaussianPrior(void *p) {
      delete ((::BCGaussianPrior*)p);
   }
   static void deleteArray_BCGaussianPrior(void *p) {
      delete [] ((::BCGaussianPrior*)p);
   }
   static void destruct_BCGaussianPrior(void *p) {
      typedef ::BCGaussianPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCGaussianPrior

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCH1D(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCH1D : new ::BCH1D;
   }
   static void *newArray_BCH1D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCH1D[nElements] : new ::BCH1D[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCH1D(void *p) {
      delete ((::BCH1D*)p);
   }
   static void deleteArray_BCH1D(void *p) {
      delete [] ((::BCH1D*)p);
   }
   static void destruct_BCH1D(void *p) {
      typedef ::BCH1D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCH1D

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCH2D(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCH2D : new ::BCH2D;
   }
   static void *newArray_BCH2D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCH2D[nElements] : new ::BCH2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCH2D(void *p) {
      delete ((::BCH2D*)p);
   }
   static void deleteArray_BCH2D(void *p) {
      delete [] ((::BCH2D*)p);
   }
   static void destruct_BCH2D(void *p) {
      typedef ::BCH2D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCH2D

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCHistogramBase(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCHistogramBase : new ::BCHistogramBase;
   }
   static void *newArray_BCHistogramBase(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCHistogramBase[nElements] : new ::BCHistogramBase[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCHistogramBase(void *p) {
      delete ((::BCHistogramBase*)p);
   }
   static void deleteArray_BCHistogramBase(void *p) {
      delete [] ((::BCHistogramBase*)p);
   }
   static void destruct_BCHistogramBase(void *p) {
      typedef ::BCHistogramBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCHistogramBase

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCIntegrate(void *p) {
      delete ((::BCIntegrate*)p);
   }
   static void deleteArray_BCIntegrate(void *p) {
      delete [] ((::BCIntegrate*)p);
   }
   static void destruct_BCIntegrate(void *p) {
      typedef ::BCIntegrate current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCIntegrate

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCLog(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCLog : new ::BCLog;
   }
   static void *newArray_BCLog(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCLog[nElements] : new ::BCLog[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCLog(void *p) {
      delete ((::BCLog*)p);
   }
   static void deleteArray_BCLog(void *p) {
      delete [] ((::BCLog*)p);
   }
   static void destruct_BCLog(void *p) {
      typedef ::BCLog current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCLog

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCModel(void *p) {
      delete ((::BCModel*)p);
   }
   static void deleteArray_BCModel(void *p) {
      delete [] ((::BCModel*)p);
   }
   static void destruct_BCModel(void *p) {
      typedef ::BCModel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCModel

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCModelManager(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCModelManager : new ::BCModelManager;
   }
   static void *newArray_BCModelManager(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCModelManager[nElements] : new ::BCModelManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCModelManager(void *p) {
      delete ((::BCModelManager*)p);
   }
   static void deleteArray_BCModelManager(void *p) {
      delete [] ((::BCModelManager*)p);
   }
   static void destruct_BCModelManager(void *p) {
      typedef ::BCModelManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCModelManager

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCObservable(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCObservable : new ::BCObservable;
   }
   static void *newArray_BCObservable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCObservable[nElements] : new ::BCObservable[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCObservable(void *p) {
      delete ((::BCObservable*)p);
   }
   static void deleteArray_BCObservable(void *p) {
      delete [] ((::BCObservable*)p);
   }
   static void destruct_BCObservable(void *p) {
      typedef ::BCObservable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCObservable

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCVariableSetlEBCObservablegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCVariableSet<BCObservable> : new ::BCVariableSet<BCObservable>;
   }
   static void *newArray_BCVariableSetlEBCObservablegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCVariableSet<BCObservable>[nElements] : new ::BCVariableSet<BCObservable>[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCVariableSetlEBCObservablegR(void *p) {
      delete ((::BCVariableSet<BCObservable>*)p);
   }
   static void deleteArray_BCVariableSetlEBCObservablegR(void *p) {
      delete [] ((::BCVariableSet<BCObservable>*)p);
   }
   static void destruct_BCVariableSetlEBCObservablegR(void *p) {
      typedef ::BCVariableSet<BCObservable> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCVariableSet<BCObservable>

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCParameter(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCParameter : new ::BCParameter;
   }
   static void *newArray_BCParameter(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCParameter[nElements] : new ::BCParameter[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCParameter(void *p) {
      delete ((::BCParameter*)p);
   }
   static void deleteArray_BCParameter(void *p) {
      delete [] ((::BCParameter*)p);
   }
   static void destruct_BCParameter(void *p) {
      typedef ::BCParameter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCParameter

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCParameterSet(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCParameterSet : new ::BCParameterSet;
   }
   static void *newArray_BCParameterSet(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCParameterSet[nElements] : new ::BCParameterSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCParameterSet(void *p) {
      delete ((::BCParameterSet*)p);
   }
   static void deleteArray_BCParameterSet(void *p) {
      delete [] ((::BCParameterSet*)p);
   }
   static void destruct_BCParameterSet(void *p) {
      typedef ::BCParameterSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCParameterSet

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCPrior(void *p) {
      delete ((::BCPrior*)p);
   }
   static void deleteArray_BCPrior(void *p) {
      delete [] ((::BCPrior*)p);
   }
   static void destruct_BCPrior(void *p) {
      typedef ::BCPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCPrior

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCPriorModel(void *p) {
      delete ((::BCPriorModel*)p);
   }
   static void deleteArray_BCPriorModel(void *p) {
      delete [] ((::BCPriorModel*)p);
   }
   static void destruct_BCPriorModel(void *p) {
      typedef ::BCPriorModel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCPriorModel

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCSplitGaussianPrior(void *p) {
      delete ((::BCSplitGaussianPrior*)p);
   }
   static void deleteArray_BCSplitGaussianPrior(void *p) {
      delete [] ((::BCSplitGaussianPrior*)p);
   }
   static void destruct_BCSplitGaussianPrior(void *p) {
      typedef ::BCSplitGaussianPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCSplitGaussianPrior

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCTF1LogPrior(void *p) {
      delete ((::BCTF1LogPrior*)p);
   }
   static void deleteArray_BCTF1LogPrior(void *p) {
      delete [] ((::BCTF1LogPrior*)p);
   }
   static void destruct_BCTF1LogPrior(void *p) {
      typedef ::BCTF1LogPrior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCTF1LogPrior

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCTF1Prior(void *p) {
      delete ((::BCTF1Prior*)p);
   }
   static void deleteArray_BCTF1Prior(void *p) {
      delete [] ((::BCTF1Prior*)p);
   }
   static void destruct_BCTF1Prior(void *p) {
      typedef ::BCTF1Prior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCTF1Prior

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_BCTH1Prior(void *p) {
      delete ((::BCTH1Prior*)p);
   }
   static void deleteArray_BCTH1Prior(void *p) {
      delete [] ((::BCTH1Prior*)p);
   }
   static void destruct_BCTH1Prior(void *p) {
      typedef ::BCTH1Prior current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCTH1Prior

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_BCVariable(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCVariable : new ::BCVariable;
   }
   static void *newArray_BCVariable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::BCVariable[nElements] : new ::BCVariable[nElements];
   }
   // Wrapper around operator delete
   static void delete_BCVariable(void *p) {
      delete ((::BCVariable*)p);
   }
   static void deleteArray_BCVariable(void *p) {
      delete [] ((::BCVariable*)p);
   }
   static void destruct_BCVariable(void *p) {
      typedef ::BCVariable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::BCVariable

/********************************************************
* libBAT_rdict.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_tagtablelibBAT_rdict();

extern "C" void G__set_cpp_environmentlibBAT_rdict() {
  G__cpp_reset_tagtablelibBAT_rdict();
}
#include <new>
extern "C" int G__cpp_dllrevlibBAT_rdict() { return(30051515); }

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

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

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

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

static int G__libBAT_rdict_215_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCHistogramBase& obj = ((BCHistogramBase*) G__getstructoffset())->operator=((TH1*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_215_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDimension());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TLegend& obj = ((BCHistogramBase*) G__getstructoffset())->GetLegend();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCHistogramBase*) G__getstructoffset())->GetNLegendColumns());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((BCHistogramBase*) G__getstructoffset())->GetBestFitParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCHistogramBase*) G__getstructoffset())->GetBestFitParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((BCHistogramBase*) G__getstructoffset())->GetLocalMode();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCHistogramBase*) G__getstructoffset())->GetLocalMode();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_215_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetBandOvercoverage());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__libBAT_rdict_215_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const BCHistogramBase*) G__getstructoffset())->GetBandFillStyle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCHistogramBase*) G__getstructoffset())->GetNBands());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCHistogramBase*) G__getstructoffset())->GetNSmooth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawGlobalMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawGlobalModeArrows());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawLocalMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawLocalModeArrows());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawMean());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetDrawStandardDeviation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetLogx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetLogy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetLogz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetGridx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->GetGridy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((BCHistogramBase*) G__getstructoffset())->GetIntervals();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCHistogramBase*) G__getstructoffset())->GetIntervals();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((BCHistogramBase*) G__getstructoffset())->GetROOToptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCHistogramBase*) G__getstructoffset())->GetROOToptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetGlobalMode(*((vector<double>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetGlobalMode((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetLocalMode(*((vector<double>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetLocalMode((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetColorScheme((BCHistogramBase::BCHColorScheme) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetBandColor((unsigned int) G__int(libp->para[0]), (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetBandOvercoverage((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetBandOvercoverage();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__libBAT_rdict_215_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetBandFillStyle((short) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetHistogram((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetLogx((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetLogx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetLogy((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetLogy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetLogz((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetLogz();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetGridx((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetGridx();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetGridy((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetGridy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetNBands((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetNSmooth((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawGlobalMode((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawGlobalMode((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawGlobalMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawLocalMode((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawLocalMode((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawLocalMode();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawMean((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawMean((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawMean();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawLegend((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetDrawLegend();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetNLegendColumns((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->SetStats((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->SetStats();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetIntervals(*((vector<double>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_215_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->SetROOToptions(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCHistogramBase*) G__getstructoffset())->Valid());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_215_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->Smooth((int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCHistogramBase*) G__getstructoffset())->Smooth();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_215_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->DrawBands(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__libBAT_rdict_215_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCHistogramBase*) G__getstructoffset())->GetNonzeroBinDensityMassVector(*(vector<std::pair<double,double> >*) libp->para[0].ref, (int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCHistogramBase*) G__getstructoffset())->GetNonzeroBinDensityMassVector(*(vector<std::pair<double,double> >*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalBounds(*((vector<double>*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalBounds(*((vector<double>*) G__int(libp->para[0])));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalSize(*((vector<double>*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalSize(*((vector<double>*) G__int(libp->para[0])));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalSize((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCHistogramBase*) G__getstructoffset())->GetSmallestIntervalSize((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCHistogramBase*) G__getstructoffset())->CheckIntervals(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCHistogramBase*) G__getstructoffset())->DefaultIntervals((int) G__int(libp->para[0]));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCHistogramBase*) G__getstructoffset())->DefaultIntervals();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((BCHistogramBase*) G__getstructoffset())->AddLegendEntry((TObject*) G__int(libp->para[0]), *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_215_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((BCHistogramBase*) G__getstructoffset())->AddBandLegendEntry((TObject*) G__int(libp->para[0]), *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

static int G__libBAT_rdict_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) BCLog::GetPrefix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::SetLogLevelFile((BCLog::LogLevel) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::SetLogLevelScreen((BCLog::LogLevel) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::SetLogLevel((BCLog::LogLevel) G__int(libp->para[0]), (BCLog::LogLevel) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::SetLogLevel((BCLog::LogLevel) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::SetPrefix((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      BCLog::OpenLog(*(string*) libp->para[0].ref, (BCLog::LogLevel) G__int(libp->para[1])
, (BCLog::LogLevel) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      BCLog::OpenLog(*(string*) libp->para[0].ref, (BCLog::LogLevel) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      BCLog::OpenLog(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      BCLog::OpenLog();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) BCLog::IsOpen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::CloseLog();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::Out((BCLog::LogLevel) G__int(libp->para[0]), (BCLog::LogLevel) G__int(libp->para[1])
, *(string*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::Out(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::Out((BCLog::LogLevel) G__int(libp->para[0]), *(string*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::OutError(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::OutWarning(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::OutSummary(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::OutDetail(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::OutDebug(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCLog::StartupInfo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = BCLog::GetVersion();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_234_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = BCLog::ToString((BCLog::LogLevel) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* BCMath */
static int G__libBAT_rdict_250_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) BCMath::LogGaus((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;
   case 3:
      G__letdouble(result7, 100, (double) BCMath::LogGaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) BCMath::LogGaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) BCMath::LogGaus((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) BCMath::LogSplitGaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) BCMath::LogSplitGaus((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;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogPoisson((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogApproxBinomial((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) BCMath::LogBreitWignerNonRel((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;
   case 3:
      G__letdouble(result7, 100, (double) BCMath::LogBreitWignerNonRel((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__libBAT_rdict_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogBreitWignerRel((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogChi2((double) G__double(libp->para[0]), (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogVoigtian((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogGammaPDF((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_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) BCMath::LogLogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) BCMath::LogLogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) BCMath::LogLogNormal((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::ApproxBinomial((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogBinomFactor((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::ApproxLogFact((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogBinomFactorExact((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::LogFact((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) BCMath::CacheFactorials((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) BCMath::Nint((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) BCMath::CorrectPValue(*(double*) G__Doubleref(&libp->para[0]), *(unsigned int*) G__UIntref(&libp->para[1])
, *(unsigned int*) G__UIntref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) BCMath::FastPValue(*(vector<unsigned>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) BCMath::FastPValue(*(vector<unsigned>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) BCMath::FastPValue(*(vector<unsigned>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__libBAT_rdict_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   BCVariable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     } else {
       p = new((void*) gvp) BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) BCVariable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCVariable*) G__getstructoffset())->GetPrefix();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCVariable*) G__getstructoffset())->GetName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCVariable*) G__getstructoffset())->GetSafeName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCVariable*) G__getstructoffset())->GetLatexName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCVariable*) G__getstructoffset())->GetUnitString();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->GetLatexNameWithUnits();
         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__libBAT_rdict_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCVariable*) G__getstructoffset())->GetLowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCVariable*) G__getstructoffset())->GetPrecision());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariable*) G__getstructoffset())->FillH1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariable*) G__getstructoffset())->FillH2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCVariable*) G__getstructoffset())->GetNbins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->SetName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->SetLatexName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->SetUnitString(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCVariable*) G__getstructoffset())->SetLimits((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCVariable*) G__getstructoffset())->SetLimits((double) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCVariable*) G__getstructoffset())->SetLimits();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->SetPrecision((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->FillHistograms((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->FillHistograms((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->FillH1((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->FillH2((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariable*) G__getstructoffset())->SetNbins((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariable*) G__getstructoffset())->IsNamed(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariable*) G__getstructoffset())->IsSafeNamed(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCVariable*) G__getstructoffset())->PositionInRange((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCVariable*) G__getstructoffset())->ValueFromPositionInRange((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCVariable*) G__getstructoffset())->CalculatePrecision((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCVariable*) G__getstructoffset())->CalculatePrecision();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_254_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCVariable*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->OneLineSummary((bool) G__int(libp->para[0]), (int) G__int(libp->para[1]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->OneLineSummary((bool) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->OneLineSummary();
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->H1Title();
         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__libBAT_rdict_254_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->H2Title(*(BCVariable*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCVariable*) G__getstructoffset())->H3Title(*(BCVariable*) libp->para[0].ref, *(BCVariable*) libp->para[1].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCVariable*) G__getstructoffset())->CreateH1(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCVariable*) G__getstructoffset())->CreateH2(*(string*) libp->para[0].ref, *(BCVariable*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_254_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCVariable*) G__getstructoffset())->CreateH3(*(string*) libp->para[0].ref, *(BCVariable*) libp->para[1].ref
, *(BCVariable*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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


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

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

static int G__libBAT_rdict_255_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((BCDataPoint*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_255_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const BCDataPoint*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_255_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((BCDataPoint*) G__getstructoffset())->GetValues();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_255_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCDataPoint*) G__getstructoffset())->GetValues();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_255_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCDataPoint*) G__getstructoffset())->GetNValues());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_255_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCDataPoint*) G__getstructoffset())->SetValues(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_255_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCDataPoint*) G__getstructoffset())->SetNValues((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCDataPoint*) G__getstructoffset())->SetNValues((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_255_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const BCDataPoint*) G__getstructoffset())->PrintSummary((void (*)(const std::string&) ) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const BCDataPoint*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

static int G__libBAT_rdict_259_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((BCDataSet*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((const BCDataSet*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCDataSet*) G__getstructoffset())->GetNDataPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCDataSet*) G__getstructoffset())->GetNValuesPerPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((BCDataSet*) G__getstructoffset())->GetDataPoint((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((const BCDataSet*) G__getstructoffset())->GetDataPoint((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((BCDataSet*) G__getstructoffset())->Back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCDataSet*) G__getstructoffset())->GetDataComponents((unsigned int) G__int(libp->para[0]));
         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__libBAT_rdict_259_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCDataSet*) G__getstructoffset())->BoundsExist());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((const BCDataSet*) G__getstructoffset())->GetLowerBounds();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((const BCDataSet*) G__getstructoffset())->GetUpperBounds();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((BCDataSet*) G__getstructoffset())->GetUserLowerBounds();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCDataPoint& obj = ((BCDataSet*) G__getstructoffset())->GetUserUpperBounds();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_259_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCDataSet*) G__getstructoffset())->SetNValuesPerPoint((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((BCDataSet*) G__getstructoffset())->SetBounds((unsigned 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:
      ((BCDataSet*) G__getstructoffset())->SetBounds((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCDataSet*) G__getstructoffset())->Fix((unsigned int) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCDataSet*) G__getstructoffset())->Fix((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFile(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (char) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFile(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFile(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFileTree(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (char) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFileTree(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->ReadDataFromFileTxt(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCDataSet*) G__getstructoffset())->AddDataPoint(*(BCDataPoint*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((BCDataSet*) G__getstructoffset())->AdjustBoundForUncertainties((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (int) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((BCDataSet*) G__getstructoffset())->AdjustBoundForUncertainties((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (unsigned int) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_259_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const BCDataSet*) G__getstructoffset())->PrintSummary((void (*)(const std::string&) ) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const BCDataSet*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_259_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->GetGraph((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->GetGraph((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
, (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_259_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->CreateH2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6]), (double) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->CreateH2(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->CreateH2((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->CreateH2((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((const BCDataSet*) G__getstructoffset())->CreateH2((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

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

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

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

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

static int G__libBAT_rdict_264_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCH1D*) G__getstructoffset())->GetQuantile((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCH1D*) G__getstructoffset())->GetLimit((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_264_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((BCH1D*) G__getstructoffset())->GetNQuantiles());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__libBAT_rdict_264_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH1D*) G__getstructoffset())->SetBandType((BCH1D::BCH1DBandType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH1D*) G__getstructoffset())->SetDrawQuantiles((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_264_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCH1D*) G__getstructoffset())->SetDrawMedian((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCH1D*) G__getstructoffset())->SetDrawMedian((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCH1D*) G__getstructoffset())->SetDrawMedian();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH1D*) G__getstructoffset())->CheckIntervals(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCH1D*) G__getstructoffset())->DrawBands(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((BCH1D*) G__getstructoffset())->DrawBands();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH1D*) G__getstructoffset())->DrawQuantiles((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_264_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCH1D*) G__getstructoffset())->PrintSummary(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, *((vector<double>*) G__int(libp->para[2])));
      G__setnull(result7);
      break;
   case 2:
      ((BCH1D*) G__getstructoffset())->PrintSummary(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCH1D*) G__getstructoffset())->PrintSummary(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((BCH1D*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<BCH1D::BCH1DSmallestInterval>* pobj;
         vector<BCH1D::BCH1DSmallestInterval> xobj = ((BCH1D*) G__getstructoffset())->GetSmallestIntervals(*((vector<double>*) G__int(libp->para[0])));
         pobj = new vector<BCH1D::BCH1DSmallestInterval>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         BCH1D::BCH1DSmallestInterval* pobj;
         BCH1D::BCH1DSmallestInterval xobj = ((BCH1D*) G__getstructoffset())->GetSmallestIntervals((double) G__double(libp->para[0]));
         pobj = new BCH1D::BCH1DSmallestInterval(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_264_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((BCH1D*) G__getstructoffset())->GetSubHistogram((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(string*) libp->para[2].ref, (bool) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((BCH1D*) G__getstructoffset())->GetSubHistogram((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(string*) libp->para[2].ref));
      break;
   case 2:
      G__letint(result7, 85, (long) ((BCH1D*) G__getstructoffset())->GetSubHistogram((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__libBAT_rdict_276_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH2D*) G__getstructoffset())->SetBandType((BCH2D::BCH2DBandType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCH2D*) G__getstructoffset())->SetLogz((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCH2D*) G__getstructoffset())->SetLogz();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCH2D*) G__getstructoffset())->SetDrawProfileX((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCH2D*) G__getstructoffset())->SetDrawProfileX();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH2D*) G__getstructoffset())->SetProfileXType((BCH2D::BCH2DProfileType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_276_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCH2D*) G__getstructoffset())->SetDrawProfileY((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCH2D*) G__getstructoffset())->SetDrawProfileY();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH2D*) G__getstructoffset())->SetProfileYType((BCH2D::BCH2DProfileType) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_276_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCH2D*) G__getstructoffset())->CheckIntervals(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCH2D*) G__getstructoffset())->DrawBands(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((BCH2D*) G__getstructoffset())->DrawBands();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_276_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((BCH2D*) G__getstructoffset())->CalculateProfileGraph((BCH2D::BCH2DProfileAxis) G__int(libp->para[0]), (BCH2D::BCH2DProfileType) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((BCH2D*) G__getstructoffset())->CalculateProfileGraph((BCH2D::BCH2DProfileAxis) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* BCPrior */
static int G__libBAT_rdict_280_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetLogPrior((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_280_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCPrior*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetLogNormalizedPrior((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_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) ((BCPrior*) G__getstructoffset())->GetPrior((double) G__double(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetPrior((double) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF1& obj = ((BCPrior*) G__getstructoffset())->GetFunction();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF1& obj = ((const BCPrior*) G__getstructoffset())->GetFunction();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMode((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMode((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetRawMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetRawMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetRawMoment((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetIntegral((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetIntegral((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetIntegral());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetCentralMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetCentralMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetCentralMoment((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardizedMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardizedMoment((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardizedMoment((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMean((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMean((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetMean());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetVariance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetVariance((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetVariance());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardDeviation((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardDeviation((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetStandardDeviation());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetSkewness((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetSkewness((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetSkewness());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetKurtosis((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetKurtosis((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetKurtosis());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetRandomValue((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (TRandom*) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->GetRandomValue((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_280_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->CalculateAndStoreIntegral((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->CalculateAndStoreIntegral((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((BCPrior*) G__getstructoffset())->CalculateAndStoreIntegral());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_280_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCPrior*) G__getstructoffset())->FillHistogramByCenterValue((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCPrior*) G__getstructoffset())->FillHistogramByIntegral((TH1*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         BCH1D* pobj;
         BCH1D xobj = ((BCPrior*) G__getstructoffset())->GetBCH1D((TH1*) G__int(libp->para[0]), *(string*) libp->para[1].ref);
         pobj = new BCH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         BCH1D* pobj;
         BCH1D xobj = ((BCPrior*) G__getstructoffset())->GetBCH1D((TH1*) G__int(libp->para[0]));
         pobj = new BCH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_280_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         BCH2D* pobj;
         BCH2D xobj = ((BCPrior*) G__getstructoffset())->GetBCH2D((BCPrior*) G__int(libp->para[0]), (TH2*) G__int(libp->para[1])
, *(string*) libp->para[2].ref);
         pobj = new BCH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         BCH2D* pobj;
         BCH2D xobj = ((BCPrior*) G__getstructoffset())->GetBCH2D((BCPrior*) G__int(libp->para[0]), (TH2*) G__int(libp->para[1]));
         pobj = new BCH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__libBAT_rdict_281_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   BCParameter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     } else {
       p = new((void*) gvp) BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) BCParameter(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_281_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCParameter*) G__getstructoffset())->Fixed());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_281_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCParameter*) G__getstructoffset())->GetPrior((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_281_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCParameter*) G__getstructoffset())->GetLogPrior((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_281_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCParameter*) G__getstructoffset())->Fix((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_281_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCParameter*) G__getstructoffset())->SetPrior((BCPrior*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* BCAux */
static int G__libBAT_rdict_314_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCAux::SetStyle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCAux::DefaultToPDF(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) BCAux::Transpose((TH2*) G__int(libp->para[0]), *(string*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 85, (long) BCAux::Transpose((TH2*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) BCAux::RangeType((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCAux::MakeFinite(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         string* pobj;
         string xobj = BCAux::SafeName(*(string*) libp->para[0].ref);
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) BCAux::AllowedCharacter((char) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      BCAux::SetKnowledgeUpdateDrawingStyle(*(BCH1D*) libp->para[0].ref, *(BCH1D*) libp->para[1].ref
, (BCAux::BCKnowledgeUpdateDrawingStyle) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      BCAux::SetKnowledgeUpdateDrawingStyle(*(BCH1D*) libp->para[0].ref, *(BCH1D*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      BCAux::SetKnowledgeUpdateDrawingStyle(*(BCH2D*) libp->para[0].ref, *(BCH2D*) libp->para[1].ref
, (BCAux::BCKnowledgeUpdateDrawingStyle) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      BCAux::SetKnowledgeUpdateDrawingStyle(*(BCH2D*) libp->para[0].ref, *(BCH2D*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCAux::DrawKnowledgeUpdate(*(BCHistogramBase*) libp->para[0].ref, *(BCHistogramBase*) libp->para[1].ref
, (bool) G__int(libp->para[2]), *(BCAux::BCTrash<TObject>*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 104, (long) BCAux::PrintPlots(*(vector<BCH1D>*) libp->para[0].ref, *(vector<BCH2D>*) libp->para[1].ref
, *(string*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 104, (long) BCAux::PrintPlots(*(vector<BCH1D>*) libp->para[0].ref, *(vector<BCH2D>*) libp->para[1].ref
, *(string*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 104, (long) BCAux::PrintPlots(*(vector<BCH1D>*) libp->para[0].ref, *(vector<BCH2D>*) libp->para[1].ref
, *(string*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

static int G__libBAT_rdict_350_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   BCObservable* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     } else {
       p = new((void*) gvp) BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref);
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref);
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) BCObservable(
*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_350_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCObservable*) G__getstructoffset())->operator=(*(double*) G__Doubleref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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


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

static int G__libBAT_rdict_351_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCVariableSet<BCObservable>*) G__getstructoffset())->Add(*(BCObservable*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((BCVariableSet<BCObservable>*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref));
      break;
   case 4:
      G__letint(result7, 103, (long) ((BCVariableSet<BCObservable>*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref));
      break;
   case 3:
      G__letint(result7, 103, (long) ((BCVariableSet<BCObservable>*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCVariableSet<BCObservable>*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->operator[]((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCVariableSet<BCObservable>*) G__getstructoffset())->At((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->At((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCVariableSet<BCObservable>*) G__getstructoffset())->Get(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Get(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCVariableSet<BCObservable>*) G__getstructoffset())->Back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Index(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->SetNBins((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->SetPrecision((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->FillHistograms((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->FillHistograms((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->FillH1((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCVariableSet<BCObservable>*) G__getstructoffset())->FillH2((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->MaxNameLength());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->Volume());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCVariableSet<BCObservable>*) G__getstructoffset())->IsWithinLimits(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->PositionInRange(*(vector<double>*) libp->para[0].ref);
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCVariableSet<BCObservable>*) G__getstructoffset())->ValueFromPositionInRange(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_351_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->GetRangeCenters();
         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__libBAT_rdict_351_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCVariableSet<BCObservable>*) G__getstructoffset())->GetUniformRandomValues((TRandom*) G__int(libp->para[0]));
         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__libBAT_rdict_351_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCVariableSet<BCObservable>*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

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

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


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

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

static int G__libBAT_rdict_357_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF1& obj = ((BCTF1LogPrior*) G__getstructoffset())->GetLogFunction();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_357_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TF1& obj = ((const BCTF1LogPrior*) G__getstructoffset())->GetLogFunction();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

static int G__libBAT_rdict_381_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCTH1Prior*) G__getstructoffset())->SetInterpolate((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_381_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1& obj = ((BCTH1Prior*) G__getstructoffset())->GetHistogram();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_381_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TH1& obj = ((const BCTH1Prior*) G__getstructoffset())->GetHistogram();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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


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

static int G__libBAT_rdict_383_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCParameterSet*) G__getstructoffset())->GetNFixedParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCParameterSet*) G__getstructoffset())->GetNFreeParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((const BCParameterSet*) G__getstructoffset())->ArePriorsSet((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const BCParameterSet*) G__getstructoffset())->ArePriorsSet());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCParameterSet*) G__getstructoffset())->IsAtFixedValues(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCParameterSet*) G__getstructoffset())->GetRandomValuesAccordingToPriors((TRandom*) G__int(libp->para[0]));
         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__libBAT_rdict_383_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCParameterSet*) G__getstructoffset())->SetPriorConstantAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCParameterSet*) G__getstructoffset())->GetLogPrior(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCParameterSet*) G__getstructoffset())->GetFixedValues((bool) G__int(libp->para[0]));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCParameterSet*) G__getstructoffset())->GetFixedValues();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_383_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCParameterSet*) G__getstructoffset())->ApplyFixedValues(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

static int G__libBAT_rdict_453_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetSafeName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNChains());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNLag());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetCurrentChain());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNIterationsPreRun());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNIterationsPreRunMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNIterationsPreRunMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNIterationsRun());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNIterationsPreRunCheck());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((BCEngineMCMC*) G__getstructoffset())->GetPreRunCheckClear());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_453_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::vector<double> >& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetScaleFactors();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCEngineMCMC::ChainState& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetChainState((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCEngineMCMC*) G__getstructoffset())->Getx((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_453_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetInitialPositionAttemptLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetProposeMultivariate());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetMultivariateCovarianceUpdates());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_453_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetRValueParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetCorrectRValueForSamplingVariability());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetFlagRun());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_453_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCEngineMCMC::Statistics& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetStatistics();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCEngineMCMC::Statistics& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetStatistics((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<BCEngineMCMC::Statistics>& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetStatisticsVector();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetRescaleHistogramRangesAfterPreRun());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<unsigned>* pobj;
         const vector<unsigned> xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetH1DPrintOrder();
         pobj = new vector<unsigned>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<std::pair<unsigned,unsigned> >* pobj;
         const vector<std::pair<unsigned,unsigned> > xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetH2DPrintOrder();
         pobj = new vector<std::pair<unsigned,unsigned> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalizedHistogram(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalizedHistogram(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH1D* pobj;
         const BCH1D xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalized(*(string*) libp->para[0].ref);
         pobj = new BCH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH1D* pobj;
         const BCH1D xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalized((unsigned int) G__int(libp->para[0]));
         pobj = new BCH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH2D* pobj;
         const BCH2D xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalized(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
         pobj = new BCH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH2D* pobj;
         const BCH2D xobj = ((const BCEngineMCMC*) G__getstructoffset())->GetMarginalized((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new BCH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetMaximumParameterNameLength((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetMaximumParameterNameLength());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCVariable& obj = ((BCEngineMCMC*) G__getstructoffset())->GetVariable((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCVariable& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetVariable((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNVariables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameterSet& obj = ((BCEngineMCMC*) G__getstructoffset())->GetParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameterSet& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameter& obj = ((BCEngineMCMC*) G__getstructoffset())->GetParameter((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameter& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetParameter((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameter& obj = ((BCEngineMCMC*) G__getstructoffset())->GetParameter(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCParameter& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetParameter(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNFixedParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNFreeParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservableSet& obj = ((BCEngineMCMC*) G__getstructoffset())->GetObservables();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservableSet& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetObservables();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCEngineMCMC*) G__getstructoffset())->GetObservable((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetObservable((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((BCEngineMCMC*) G__getstructoffset())->GetObservable(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCObservable& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetObservable(*(string*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetNObservables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetBestFitParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const BCEngineMCMC*) G__getstructoffset())->GetBestFitParameterErrors();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const vector<double>& obj = ((BCEngineMCMC*) G__getstructoffset())->GetLocalModes((bool) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const vector<double>& obj = ((BCEngineMCMC*) G__getstructoffset())->GetLocalModes();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->GetReuseObservables());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH1D& obj = ((BCEngineMCMC*) G__getstructoffset())->GetBCH1DdrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH2D& obj = ((BCEngineMCMC*) G__getstructoffset())->GetBCH2DdrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetName(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetInitialScaleFactors(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNChains((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNLag((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNIterationsPreRunMax((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNIterationsRun((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNIterationsPreRunMin((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNIterationsPreRunCheck((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPreRunCheckClear((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetRandomSeed((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetInitialPositions(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetInitialPositions(*(vector<std::vector<double> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetInitialPositionScheme((BCEngineMCMC::InitialPositionScheme) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetInitialPositionAttemptLimit((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetProposeMultivariate((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->SetProposalFunctionDof((double) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->SetProposalFunctionDof();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_453_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetFlagFillHistograms((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetFlagFillHistograms((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParPar((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParPar((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParPar(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParPar(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParObs((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParObs((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParObs(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramParObs(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsObs((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsObs((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsObs(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsObs(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsPar((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsPar((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsPar(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetFillHistogramObsPar(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetFlagPreRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->SetCorrectRValueForSamplingVariability((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->SetCorrectRValueForSamplingVariability();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPrecision((BCEngineMCMC::Precision) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetNbins((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetReuseObservables((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->SetRescaleHistogramRangesAfterPreRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->SetRescaleHistogramRangesAfterPreRun();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChain((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChainRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChainPreRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]), (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorConstant((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorConstant(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior((unsigned int) G__int(libp->para[0]), *(TF1*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior((unsigned int) G__int(libp->para[0]), *(TF1*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior(*(string*) libp->para[0].ref, *(TF1*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior(*(string*) libp->para[0].ref, *(TF1*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorDelta((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorDelta(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorGauss((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorGauss(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorGauss((unsigned int) G__int(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__libBAT_rdict_453_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->SetPriorGauss(*(string*) libp->para[0].ref, (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__libBAT_rdict_453_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior((unsigned int) G__int(libp->para[0]), *(TH1*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior((unsigned int) G__int(libp->para[0]), *(TH1*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior(*(string*) libp->para[0].ref, *(TH1*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->SetPrior(*(string*) libp->para[0].ref, *(TH1*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarginalizedDistributions(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->WriteMarginalizedDistributions(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCEngineMCMC*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const BCEngineMCMC*) G__getstructoffset())->PrintParameters(*(vector<double>*) libp->para[0].ref, (void (*)(const std::string&) ) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const BCEngineMCMC*) G__getstructoffset())->PrintParameters(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintAllMarginalized(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintAllMarginalized(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintAllMarginalized(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterPlot(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), *((vector<double>*) G__int(libp->para[3]))
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterPlot(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), *((vector<double>*) G__int(libp->para[3]))));
      break;
   case 3:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterPlot(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterPlot(*(string*) libp->para[0].ref, (int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterPlot(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->DrawParameterPlot((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), *((vector<double>*) G__int(libp->para[3]))
, (bool) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->DrawParameterPlot((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), *((vector<double>*) G__int(libp->para[3]))));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->DrawParameterPlot((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->DrawParameterPlot((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->DrawParameterPlot((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintCorrelationMatrix(*(string*) libp->para[0].ref));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintCorrelationMatrix());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintCorrelationPlot(*(string*) libp->para[0].ref, (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintCorrelationPlot(*(string*) libp->para[0].ref));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintCorrelationPlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->PrintParameterLatex(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->CreateHistograms((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->CreateHistograms();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->InitializeMarkovChainTree((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->InitializeMarkovChainTree((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->InitializeMarkovChainTree();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddParameter(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref));
      break;
   case 4:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddParameter(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref));
      break;
   case 3:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddParameter(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddParameter(*(BCParameter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddObservable(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref
, *(string*) libp->para[4].ref));
      break;
   case 4:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddObservable(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), *(string*) libp->para[3].ref));
      break;
   case 3:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddObservable(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->AddObservable(*(BCObservable*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->EvaluateObservables((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->CalculateObservables(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->GetProposalPointMetropolis((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->GetProposalPointMetropolis((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_453_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->InChainFillHistograms(*(BCEngineMCMC::ChainState*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->InChainFillTree(*(BCEngineMCMC::ChainState*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_453_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCEngineMCMC*) G__getstructoffset())->LogEval(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) BCEngineMCMC::RValue(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) BCEngineMCMC::RValue(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_453_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->MCMCCurrentPointInterface(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->LoadParametersFromTree((TTree*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->LoadParametersFromTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMCParameters(*(TTree*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->ParameterTreeMatchesModel((TTree*) G__int(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->ParameterTreeMatchesModel((TTree*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC(*(string*) libp->para[0].ref, *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])), (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC(*(string*) libp->para[0].ref, *((string*) G__int(libp->para[1]))
, *((string*) G__int(libp->para[2])));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC(*(string*) libp->para[0].ref, *((string*) G__int(libp->para[1])));
      G__setnull(result7);
      break;
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC((TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->LoadMCMC((TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->ValidMCMCTree((TTree*) G__int(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const BCEngineMCMC*) G__getstructoffset())->ValidMCMCTree((TTree*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_453_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->Remarginalize((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCEngineMCMC*) G__getstructoffset())->Remarginalize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((BCEngineMCMC*) G__getstructoffset())->PrepareToContinueMarginalization(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (bool) G__int(libp->para[3])
, (bool) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((BCEngineMCMC*) G__getstructoffset())->PrepareToContinueMarginalization(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref, (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((BCEngineMCMC*) G__getstructoffset())->PrepareToContinueMarginalization(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(string*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((BCEngineMCMC*) G__getstructoffset())->PrepareToContinueMarginalization(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((BCEngineMCMC*) G__getstructoffset())->PrepareToContinueMarginalization(*(string*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_453_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCEngineMCMC*) G__getstructoffset())->UpdateMultivariateProposalFunctionCovariances((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

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

static int G__libBAT_rdict_457_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const BCModel*) G__getstructoffset())->GetNDataPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_457_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((BCModel*) G__getstructoffset())->GetPriorModel((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((BCModel*) G__getstructoffset())->GetPriorModel((bool) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((BCModel*) G__getstructoffset())->GetPriorModel());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         BCH1D* pobj;
         BCH1D xobj = ((BCModel*) G__getstructoffset())->GetPrior((unsigned int) G__int(libp->para[0]));
         pobj = new BCH1D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         BCH2D* pobj;
         BCH2D xobj = ((BCModel*) G__getstructoffset())->GetPrior((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new BCH2D(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH1D& obj = ((BCModel*) G__getstructoffset())->GetBCH1DPriorDrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH2D& obj = ((BCModel*) G__getstructoffset())->GetBCH2DPriorDrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH1D& obj = ((BCModel*) G__getstructoffset())->GetBCH1DPosteriorDrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCH2D& obj = ((BCModel*) G__getstructoffset())->GetBCH2DPosteriorDrawingOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCModel*) G__getstructoffset())->GetDrawPriorFirst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModel*) G__getstructoffset())->SetDataSet((BCDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCModel*) G__getstructoffset())->SetKnowledgeUpdateDrawingStyle((BCAux::BCKnowledgeUpdateDrawingStyle) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCModel*) G__getstructoffset())->SetKnowledgeUpdateDrawingStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((BCModel*) G__getstructoffset())->SetDrawPriorFirst((bool) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((BCModel*) G__getstructoffset())->SetDrawPriorFirst();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->APrioriProbability(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->LogAPrioriProbability(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->Likelihood(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->LogLikelihood(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->ProbabilityNN(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->LogProbabilityNN(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->Probability(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->LogProbability(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->SamplingFunction(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCModel*) G__getstructoffset())->HessianMatrixElement((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(vector<double>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_457_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModel*) G__getstructoffset())->PrintHessianMatrix(*((vector<double>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_457_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 104, (long) ((BCModel*) G__getstructoffset())->PrintKnowledgeUpdatePlots(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 104, (long) ((BCModel*) G__getstructoffset())->PrintKnowledgeUpdatePlots(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 104, (long) ((BCModel*) G__getstructoffset())->PrintKnowledgeUpdatePlots(*(string*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((BCModel*) G__getstructoffset())->PrintKnowledgeUpdatePlots(*(string*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

static int G__libBAT_rdict_522_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCIntegrate*) G__getstructoffset())->GetRandomVectorInParameterSpace(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCIntegrate*) G__getstructoffset())->GetRandomPoint(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__libBAT_rdict_522_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCCubaOptions::Vegas& obj = ((const BCIntegrate*) G__getstructoffset())->GetCubaVegasOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCCubaOptions::Suave& obj = ((const BCIntegrate*) G__getstructoffset())->GetCubaSuaveOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCCubaOptions::Divonne& obj = ((const BCIntegrate*) G__getstructoffset())->GetCubaDivonneOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const BCCubaOptions::Cuhre& obj = ((const BCIntegrate*) G__getstructoffset())->GetCubaCuhreOptions();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*((vector<unsigned>*) G__int(libp->para[0])), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4]), (bool) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*((vector<unsigned>*) G__int(libp->para[0])), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*((vector<unsigned>*) G__int(libp->para[0])), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))));
      break;
   case 3:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*((vector<unsigned>*) G__int(libp->para[0])), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4]), (bool) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))));
      break;
   case 3:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4]), (bool) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))
, (int) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *((const vector<double>*) G__int(libp->para[3]))));
      break;
   case 3:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), *(unsigned int*) G__UIntref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(
*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4])), (int) G__int(libp->para[5])
, (bool) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4])), (int) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4]))));
      break;
   case 4:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice(
(unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4])), (int) G__int(libp->para[5])
, (bool) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4])), (int) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
, *((const vector<double>*) G__int(libp->para[4]))));
      break;
   case 4:
      G__letint(result7, 85, (long) ((BCIntegrate*) G__getstructoffset())->GetSlice((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, *(unsigned int*) G__UIntref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_522_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMinuitMinimizer& obj = ((BCIntegrate*) G__getstructoffset())->GetMinuit();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_522_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetFlagIgnorePrevOptimization((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetOptimizationMethod((BCIntegrate::BCOptimizationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetIntegrationMethod((BCIntegrate::BCIntegrationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetMarginalizationMethod((BCIntegrate::BCMarginalizationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetSASchedule((BCIntegrate::BCSASchedule) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__libBAT_rdict_522_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetCubaIntegrationMethod((BCIntegrate::BCCubaMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetCubaOptions(*(BCCubaOptions::Vegas*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetCubaOptions(*(BCCubaOptions::Suave*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetCubaOptions(*(BCCubaOptions::Divonne*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetCubaOptions(*(BCCubaOptions::Cuhre*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_522_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCIntegrate*) G__getstructoffset())->Eval(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_522_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCIntegrate*) G__getstructoffset())->Integrate((BCIntegrate::BCIntegrationMethod) G__int(libp->para[0]), G__int(libp->para[1]) ? *(BCIntegrate::tRandomizer *) G__int(libp->para[1]) : 0
, G__int(libp->para[2]) ? *(BCIntegrate::tEvaluator *) G__int(libp->para[2]) : 0, (BCIntegrate::tIntegralUpdater) G__int(libp->para[3])
, *(vector<double>*) libp->para[4].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((BCIntegrate*) G__getstructoffset())->EvaluatorMC(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(bool*) G__Boolref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      BCIntegrate::IntegralUpdaterMC(*(vector<double>*) libp->para[0].ref, *(int*) G__Intref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_522_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCIntegrate*) G__getstructoffset())->FindMode(*((vector<double>*) G__int(libp->para[0])));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCIntegrate*) G__getstructoffset())->FindMode();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCIntegrate*) G__getstructoffset())->FindMode((BCIntegrate::BCOptimizationMethod) G__int(libp->para[0]), *((vector<double>*) G__int(libp->para[1])));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         vector<double>* pobj;
         vector<double> xobj = ((BCIntegrate*) G__getstructoffset())->FindMode((BCIntegrate::BCOptimizationMethod) G__int(libp->para[0]));
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCIntegrate*) G__getstructoffset())->SATemperature((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCIntegrate*) G__getstructoffset())->SATemperatureBoltzmann((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCIntegrate*) G__getstructoffset())->SATemperatureCauchy((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCIntegrate*) G__getstructoffset())->SATemperatureCustom((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCIntegrate*) G__getstructoffset())->GetProposalPointSA(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1]));
         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__libBAT_rdict_522_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCIntegrate*) G__getstructoffset())->GetProposalPointSABoltzmann(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1]));
         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__libBAT_rdict_522_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCIntegrate*) G__getstructoffset())->GetProposalPointSACauchy(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1]));
         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__libBAT_rdict_522_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCIntegrate*) G__getstructoffset())->GetProposalPointSACustom(*(vector<double>*) libp->para[0].ref, (int) G__int(libp->para[1]));
         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__libBAT_rdict_522_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const BCIntegrate*) G__getstructoffset())->SAHelperGetRandomPointOnHypersphere();
         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__libBAT_rdict_522_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const BCIntegrate*) G__getstructoffset())->SAHelperGetRadialCauchy());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_522_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpIntegrationMethod((BCIntegrate::BCIntegrationMethod) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpCurrentIntegrationMethod();
         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__libBAT_rdict_522_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpUsedIntegrationMethod();
         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__libBAT_rdict_522_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpMarginalizationMethod((BCIntegrate::BCMarginalizationMethod) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpCurrentMarginalizationMethod();
         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__libBAT_rdict_522_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpUsedMarginalizationMethod();
         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__libBAT_rdict_522_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpOptimizationMethod((BCIntegrate::BCOptimizationMethod) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpCurrentOptimizationMethod();
         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__libBAT_rdict_522_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpUsedOptimizationMethod();
         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__libBAT_rdict_522_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpCubaIntegrationMethod((BCIntegrate::BCCubaMethod) G__int(libp->para[0]));
         pobj = new string(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const BCIntegrate*) G__getstructoffset())->DumpCubaIntegrationMethod();
         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__libBAT_rdict_522_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetBestFitParameters(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_522_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCIntegrate*) G__getstructoffset())->SetBestFitParameters(*(vector<double>*) libp->para[0].ref, *(double*) G__Doubleref(&libp->para[1])
, *(double*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__libBAT_rdict_522_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((BCIntegrate*) G__getstructoffset())->CheckMarginalizationIndices((TH1*) G__int(libp->para[0]), *(vector<unsigned>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

static int G__libBAT_rdict_537_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCPriorModel*) G__getstructoffset())->SetCallLikelihood((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_537_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const BCPriorModel*) G__getstructoffset())->GetCallLikelihood());
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* BCEmptyModel */
static int G__libBAT_rdict_538_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   BCEmptyModel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new BCEmptyModel(*(string*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) BCEmptyModel(*(string*) libp->para[0].ref);
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new BCEmptyModel[n];
       } else {
         p = new((void*) gvp) BCEmptyModel[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new BCEmptyModel;
       } else {
         p = new((void*) gvp) BCEmptyModel;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

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

static int G__libBAT_rdict_539_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((BCModelManager*) G__getstructoffset())->GetNModels());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_539_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetDataSet((BCDataSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetPrecision((BCEngineMCMC::Precision) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__libBAT_rdict_539_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetMarginalizationMethod((BCIntegrate::BCMarginalizationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetIntegrationMethod((BCIntegrate::BCIntegrationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetOptimizationMethod((BCIntegrate::BCOptimizationMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__libBAT_rdict_539_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetNbins((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->SetNChains((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((BCModelManager*) G__getstructoffset())->AddModel((BCModel*) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((BCModelManager*) G__getstructoffset())->AddModel((BCModel*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__libBAT_rdict_539_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChain((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChainRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChainPreRun((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]), (bool) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref
, (bool) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((BCModelManager*) G__getstructoffset())->WriteMarkovChain(*(string*) libp->para[0].ref, *(string*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCModelManager*) G__getstructoffset())->PrintModelComparisonSummary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__libBAT_rdict_539_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const BCModelManager*) G__getstructoffset())->PrintSummary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* Setting up global function */

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

/* BCHistogramBase */

/* BCLog */

/* BCMath */

/* BCVariable */

/* BCDataPoint */

/* BCDataSet */

/* BCH1D */

/* BCH2D */

/* BCPrior */

/* BCParameter */

/* BCAux */

/* BCConstantPrior */

/* BCGaussianPrior */

/* BCSplitGaussianPrior */

/* BCCauchyPrior */

/* BCObservable */

/* BCVariableSet<BCObservable> */

/* BCTF1Prior */

/* BCTF1LogPrior */

/* BCTH1Prior */

/* BCParameterSet */

/* BCEngineMCMC */

/* BCModel */

/* BCIntegrate */

/* BCPriorModel */

/* BCEmptyModel */

/* BCModelManager */

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

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

size_t G__get_sizep2memfunclibBAT_rdict()
{
  G__Sizep2memfunclibBAT_rdict 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_inheritancelibBAT_rdict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D))) {
     BCH1D *G__Lderived;
     G__Lderived=(BCH1D*)0x1000;
     {
       BCHistogramBase *G__Lpbase=(BCHistogramBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D),G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D))) {
     BCH2D *G__Lderived;
     G__Lderived=(BCH2D*)0x1000;
     {
       BCHistogramBase *G__Lpbase=(BCHistogramBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D),G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter))) {
     BCParameter *G__Lderived;
     G__Lderived=(BCParameter*)0x1000;
     {
       BCVariable *G__Lpbase=(BCVariable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter),G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior))) {
     BCConstantPrior *G__Lderived;
     G__Lderived=(BCConstantPrior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCGaussianPrior))) {
     BCGaussianPrior *G__Lderived;
     G__Lderived=(BCGaussianPrior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCGaussianPrior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior))) {
     BCSplitGaussianPrior *G__Lderived;
     G__Lderived=(BCSplitGaussianPrior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCCauchyPrior))) {
     BCCauchyPrior *G__Lderived;
     G__Lderived=(BCCauchyPrior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCCauchyPrior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable))) {
     BCObservable *G__Lderived;
     G__Lderived=(BCObservable*)0x1000;
     {
       BCVariable *G__Lpbase=(BCVariable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable),G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior))) {
     BCTF1Prior *G__Lderived;
     G__Lderived=(BCTF1Prior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior))) {
     BCTF1LogPrior *G__Lderived;
     G__Lderived=(BCTF1LogPrior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior))) {
     BCTH1Prior *G__Lderived;
     G__Lderived=(BCTH1Prior*)0x1000;
     {
       BCPrior *G__Lpbase=(BCPrior*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior),G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet))) {
     BCParameterSet *G__Lderived;
     G__Lderived=(BCParameterSet*)0x1000;
     {
       BCVariableSet<BCParameter> *G__Lpbase=(BCVariableSet<BCParameter>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet),G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCParametergR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel))) {
     BCModel *G__Lderived;
     G__Lderived=(BCModel*)0x1000;
     {
       BCIntegrate *G__Lpbase=(BCIntegrate*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       BCEngineMCMC *G__Lpbase=(BCEngineMCMC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate))) {
     BCIntegrate *G__Lderived;
     G__Lderived=(BCIntegrate*)0x1000;
     {
       BCEngineMCMC *G__Lpbase=(BCEngineMCMC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate),G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel))) {
     BCPriorModel *G__Lderived;
     G__Lderived=(BCPriorModel*)0x1000;
     {
       BCModel *G__Lpbase=(BCModel*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       BCIntegrate *G__Lpbase=(BCIntegrate*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       BCEngineMCMC *G__Lpbase=(BCEngineMCMC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel))) {
     BCEmptyModel *G__Lderived;
     G__Lderived=(BCEmptyModel*)0x1000;
     {
       BCModel *G__Lpbase=(BCModel*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       BCIntegrate *G__Lpbase=(BCIntegrate*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       BCEngineMCMC *G__Lpbase=(BCEngineMCMC*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel),G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

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

   /* Setting up typedef entry */
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<double,double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TObject*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETObjectmUcOallocatorlETObjectmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETObjectmUcOallocatorlETObjectmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TLegendEntry*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("void (*)(const std::string&) ",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCDataPoint>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCDataPointcOallocatorlEBCDataPointgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCDataPointcOallocatorlEBCDataPointgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCH1D::BCH1DInterval>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCH1D::BCH1DSmallestInterval>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR));
   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__libBAT_rdictLN_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__libBAT_rdictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_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__libBAT_rdictLN_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__libBAT_rdictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCH1D>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcOallocatorlEBCH1DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcOallocatorlEBCH1DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCH2D>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH2DcOallocatorlEBCH2DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH2DcOallocatorlEBCH2DgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCObservable>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCObservablecOallocatorlEBCObservablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCObservablecOallocatorlEBCObservablegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BCObservableSet",117,G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCParameter>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCParametercOallocatorlEBCParametergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCParametercOallocatorlEBCParametergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCEngineMCMC::Statistics>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<unsigned,unsigned>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_pairlEunsignedsPintcOunsignedsPintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<unsigned,unsigned> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned,unsigned> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,unsigned int> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ThreadLocalStorage>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCEngineMCMC::ThreadLocalStorage>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ChainIndex_t",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixDSym>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixTSym<double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixD>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixT<double> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ChainState>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BCEngineMCMC::ChainState>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH2*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<TH2*> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TH2*> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TH2*,allocator<TH2*> > >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<int,int> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<int,int> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<int,int> >",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("tRandomizer",97,-1,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate));
   G__setnewtype(-1,"void (BCIntegrate::*tRandomizer)(std::vector<double>&) const;",0);
   G__search_typename2("tEvaluator",97,-1,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate));
   G__setnewtype(-1,"double (BCIntegrate::*tEvaluator)(std::vector<double>&, const std::vector<double>&, bool&);",0);
   G__search_typename2("tIntegralUpdater",89,-1,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate));
   G__setnewtype(-1,"void (*tIntegralUpdater)(const std::vector<double>&, const int&, double&, double&);",0);
   G__search_typename2("vector<BCModel*>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCModelmUcOallocatorlEBCModelmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCModelmUcOallocatorlEBCModelmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR));
   G__setnewtype(-1,NULL,0);
}

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

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

   /* BCHistogramBase */
static void G__setup_memvarBCHistogramBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase));
   { BCHistogramBase *p; p=(BCHistogramBase*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme),-1,-2,1,G__FastAllocString(2048).Format("kBlackWhite=%lldLL",(long long)BCHistogramBase::kBlackWhite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme),-1,-2,1,G__FastAllocString(2048).Format("kGreenYellowRed=%lldLL",(long long)BCHistogramBase::kGreenYellowRed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme),-1,-2,1,G__FastAllocString(2048).Format("kBlueOrange=%lldLL",(long long)BCHistogramBase::kBlueOrange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme),-1,-2,1,G__FastAllocString(2048).Format("kRedGreen=%lldLL",(long long)BCHistogramBase::kRedGreen).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TH1),-1,-1,2,"fHistogram=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TLegend),-1,-1,2,"fLegend=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNLegendColumns=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fGlobalMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fLocalMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,2,"fBandColors=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fBandOvercoverage=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,-1,-1,2,"fBandFillStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fLineColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fLineStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fLineWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMarkerColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMarkerScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fLogx=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fLogy=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fLogz=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fGridx=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fGridy=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNBands=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawGlobalMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawGlobalModeArrows=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fGlobalModeMarkerStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawLocalMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawLocalModeArrows=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fLocalModeMarkerStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawMean=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMeanMarkerStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawStandardDeviation=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawLegend=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawStats=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fDimension=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fIntervals=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fROOToptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR),G__defined_typename("vector<TObject*>"),-1,2,"fROOTObjects=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR),G__defined_typename("vector<TLegendEntry*>"),-1,2,"fExtraLegendEntries=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCLog */
static void G__setup_memvarBCLog(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCLog));
   { BCLog *p; p=(BCLog*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("debug=%lldLL",(long long)BCLog::debug).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("detail=%lldLL",(long long)BCLog::detail).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("summary=%lldLL",(long long)BCLog::summary).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("warning=%lldLL",(long long)BCLog::warning).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("error=%lldLL",(long long)BCLog::error).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,1,G__FastAllocString(2048).Format("nothing=%lldLL",(long long)BCLog::nothing).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-2,4,"fVersion=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,4,"fMinimumLogLevelFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel),-1,-2,4,"fMinimumLogLevelScreen=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ofstream"),-2,4,"fOutputStream=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-2,4,"fFirstOutputDone=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-2,4,"fPrefix=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCMath */
static void G__setup_memvarBCMath(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCMath));
   {
   }
   G__tag_memvar_reset();
}


   /* BCVariable */
static void G__setup_memvarBCVariable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable));
   { BCVariable *p; p=(BCVariable*)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,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fPrefix=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fSafeName=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fLowerLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fUpperLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fPrecision=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fLatexName=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fUnitString=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFillH1=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFillH2=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNbins=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCDataPoint */
static void G__setup_memvarBCDataPoint(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint));
   { BCDataPoint *p; p=(BCDataPoint*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fData=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCDataSet */
static void G__setup_memvarBCDataSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet));
   { BCDataSet *p; p=(BCDataSet*)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,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR),G__defined_typename("vector<BCDataPoint>"),-1,4,"fDataVector=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNValuesPerPoint=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint),-1,-1,4,"fLowerBounds=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint),-1,-1,4,"fUpperBounds=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint),-1,-1,4,"fUserLowerBounds=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint),-1,-1,4,"fUserUpperBounds=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<bool>"),-1,4,"fFixed=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCH1D */
static void G__setup_memvarBCH1D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D));
   { BCH1D *p; p=(BCH1D*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kNoBands=%lldLL",(long long)BCH1D::kNoBands).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kCentralInterval=%lldLL",(long long)BCH1D::kCentralInterval).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kSmallestInterval=%lldLL",(long long)BCH1D::kSmallestInterval).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kUpperLimit=%lldLL",(long long)BCH1D::kUpperLimit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kLowerLimit=%lldLL",(long long)BCH1D::kLowerLimit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-2,1,G__FastAllocString(2048).Format("kUserSpecified=%lldLL",(long long)BCH1D::kUserSpecified).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType),-1,-1,2,"fBandType=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNQuantiles=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fQuantileLineColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawMedian=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawCentral68=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCH2D */
static void G__setup_memvarBCH2D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D));
   { BCH2D *p; p=(BCH2D*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType),-1,-2,1,G__FastAllocString(2048).Format("kNoBands=%lldLL",(long long)BCH2D::kNoBands).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType),-1,-2,1,G__FastAllocString(2048).Format("kSmallestInterval=%lldLL",(long long)BCH2D::kSmallestInterval).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType),-1,-2,1,G__FastAllocString(2048).Format("kProfileMean=%lldLL",(long long)BCH2D::kProfileMean).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType),-1,-2,1,G__FastAllocString(2048).Format("kProfileMedian=%lldLL",(long long)BCH2D::kProfileMedian).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType),-1,-2,1,G__FastAllocString(2048).Format("kProfileMode=%lldLL",(long long)BCH2D::kProfileMode).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileAxis),-1,-2,1,G__FastAllocString(2048).Format("kProfileX=%lldLL",(long long)BCH2D::kProfileX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileAxis),-1,-2,1,G__FastAllocString(2048).Format("kProfileY=%lldLL",(long long)BCH2D::kProfileY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType),-1,-1,2,"fBandType=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fLogz=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawProfileX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType),-1,-1,2,"fProfileXType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fProfileXLineColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fProfileXLineStyle=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawProfileY=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType),-1,-1,2,"fProfileYType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fProfileYLineColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fProfileYLineStyle=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCPrior */
static void G__setup_memvarBCPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior));
   { BCPrior *p; p=(BCPrior*)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,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TF1),-1,-1,2,"fPriorFunction=",0,"/< TF1 for use in default raw moment calculation");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fLogIntegral=",0,"/< Log of integral of unnormalized pdf over the range.");
   }
   G__tag_memvar_reset();
}


   /* BCParameter */
static void G__setup_memvarBCParameter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter));
   { BCParameter *p; p=(BCParameter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFixed=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fFixedValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior),-1,-1,4,"fPrior=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCAux */
static void G__setup_memvarBCAux(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCAux));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kFiniteRange=%lldLL",(long long)BCAux::kFiniteRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kNegativeInfiniteRange=%lldLL",(long long)BCAux::kNegativeInfiniteRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kPositiveInfiniteRange=%lldLL",(long long)BCAux::kPositiveInfiniteRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kInfiniteRange=%lldLL",(long long)BCAux::kInfiniteRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kEmptyRange=%lldLL",(long long)BCAux::kEmptyRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange),-1,-2,1,G__FastAllocString(2048).Format("kReverseRange=%lldLL",(long long)BCAux::kReverseRange).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle),-1,-2,1,G__FastAllocString(2048).Format("kKnowledgeUpdateDefaultStyle=%lldLL",(long long)BCAux::kKnowledgeUpdateDefaultStyle).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle),-1,-2,1,G__FastAllocString(2048).Format("kKnowledgeUpdateDetailedPosterior=%lldLL",(long long)BCAux::kKnowledgeUpdateDetailedPosterior).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle),-1,-2,1,G__FastAllocString(2048).Format("kKnowledgeUpdateDetailedPrior=%lldLL",(long long)BCAux::kKnowledgeUpdateDetailedPrior).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCConstantPrior */
static void G__setup_memvarBCConstantPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior));
   { BCConstantPrior *p; p=(BCConstantPrior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fLogRangeWidth=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCGaussianPrior */
static void G__setup_memvarBCGaussianPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCGaussianPrior));
   { BCGaussianPrior *p; p=(BCGaussianPrior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMean=",0,"/< mean of Gaussian");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSigma=",0,"/< std dev of Gaussian");
   }
   G__tag_memvar_reset();
}


   /* BCSplitGaussianPrior */
static void G__setup_memvarBCSplitGaussianPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior));
   { BCSplitGaussianPrior *p; p=(BCSplitGaussianPrior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMode=",0,"/< mode of split gaussian");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSigmaBelow=",0,"/< std dev of split gaussian below mode");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSigmaAbove=",0,"/< std dev of split gaussian above mode");
   }
   G__tag_memvar_reset();
}


   /* BCCauchyPrior */
static void G__setup_memvarBCCauchyPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCCauchyPrior));
   { BCCauchyPrior *p; p=(BCCauchyPrior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMean=",0,"/< mean of Cauchy distribution");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fScale=",0,"/< scale of Cauchy distribution");
   }
   G__tag_memvar_reset();
}


   /* BCObservable */
static void G__setup_memvarBCObservable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable));
   { BCObservable *p; p=(BCObservable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fObservableValue=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCVariableSet<BCObservable> */
static void G__setup_memvarBCVariableSetlEBCObservablegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR));
   { BCVariableSet<BCObservable> *p; p=(BCVariableSet<BCObservable>*)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,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR),G__defined_typename("vector<BCObservable>"),-1,2,"fVars=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMaxNameLength=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCTF1Prior */
static void G__setup_memvarBCTF1Prior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior));
   { BCTF1Prior *p; p=(BCTF1Prior*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* BCTF1LogPrior */
static void G__setup_memvarBCTF1LogPrior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior));
   { BCTF1LogPrior *p; p=(BCTF1LogPrior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TF1),-1,-1,2,"fLogPriorFunction=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCTH1Prior */
static void G__setup_memvarBCTH1Prior(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior));
   { BCTH1Prior *p; p=(BCTH1Prior*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TH1),-1,-1,2,"fPriorHistogram=",0,"/< TH1 holding prior");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fInterpolate=",0,"/< whether to interpolate values of hist for prior function");
   }
   G__tag_memvar_reset();
}


   /* BCParameterSet */
static void G__setup_memvarBCParameterSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet));
   { BCParameterSet *p; p=(BCParameterSet*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* BCEngineMCMC */
static void G__setup_memvarBCEngineMCMC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC));
   { BCEngineMCMC *p; p=(BCEngineMCMC*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision),-1,-2,1,G__FastAllocString(2048).Format("kLow=%lldLL",(long long)BCEngineMCMC::kLow).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision),-1,-2,1,G__FastAllocString(2048).Format("kQuick=%lldLL",(long long)BCEngineMCMC::kQuick).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision),-1,-2,1,G__FastAllocString(2048).Format("kMedium=%lldLL",(long long)BCEngineMCMC::kMedium).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision),-1,-2,1,G__FastAllocString(2048).Format("kHigh=%lldLL",(long long)BCEngineMCMC::kHigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision),-1,-2,1,G__FastAllocString(2048).Format("kVeryHigh=%lldLL",(long long)BCEngineMCMC::kVeryHigh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase),-1,-2,1,G__FastAllocString(2048).Format("kPreRun=%lldLL",(long long)BCEngineMCMC::kPreRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase),-1,-2,1,G__FastAllocString(2048).Format("kUnsetPhase=%lldLL",(long long)BCEngineMCMC::kUnsetPhase).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase),-1,-2,1,G__FastAllocString(2048).Format("kMainRun=%lldLL",(long long)BCEngineMCMC::kMainRun).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme),-1,-2,1,G__FastAllocString(2048).Format("kInitCenter=%lldLL",(long long)BCEngineMCMC::kInitCenter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme),-1,-2,1,G__FastAllocString(2048).Format("kInitRandomUniform=%lldLL",(long long)BCEngineMCMC::kInitRandomUniform).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme),-1,-2,1,G__FastAllocString(2048).Format("kInitUserDefined=%lldLL",(long long)BCEngineMCMC::kInitUserDefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme),-1,-2,1,G__FastAllocString(2048).Format("kInitRandomPrior=%lldLL",(long long)BCEngineMCMC::kInitRandomPrior).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR),G__defined_typename("vector<ThreadLocalStorage>"),-1,4,"fMCMCThreadLocalStorage=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("ChainIndex_t"),-1,4,"fChainIndex=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fSafeName=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet),-1,-1,2,"fParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR),G__defined_typename("BCObservableSet"),-1,2,"fObservables=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNChains=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNLag=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMCMCCurrentIteration=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNIterationsPreRunCheck=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCPreRunCheckClear=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fMCMCNIterationsConvergenceGlobal=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNIterationsPreRunMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNIterationsRun=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCNIterationsPreRunMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fMCMCFlagWriteChainToFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fMCMCFlagWritePreRunToFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TFile),-1,-1,2,"fMCMCOutputFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fMCMCOutputFilename=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_string),-1,-1,2,"fMCMCOutputFileOption=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCScaleFactorLowerLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCScaleFactorUpperLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<double> >"),-1,2,"fMCMCProposalFunctionScaleFactor=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fMCMCInitialScaleFactors=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR),G__defined_typename("vector<TMatrixDSym>"),-1,2,"fMultivariateProposalFunctionCovariance=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR),G__defined_typename("vector<TMatrixD>"),-1,2,"fMultivariateProposalFunctionCholeskyDecomposition=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMultivariateCovarianceUpdates=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMultivariateCovarianceUpdateLambda=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMultivariateEpsilon=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMultivariateScaleMultiplier=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<double> >"),-1,2,"fMCMCInitialPosition=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCEfficiencyMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCEfficiencyMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme),-1,-1,2,"fInitialPositionScheme=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fInitialPositionAttemptLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fMCMCProposeMultivariate=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCProposalFunctionDof=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase),-1,-1,2,"fMCMCPhase=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR),G__defined_typename("vector<ChainState>"),-1,2,"fMCMCStates=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR),G__defined_typename("vector<BCEngineMCMC::Statistics>"),-1,2,"fMCMCStatistics=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics),-1,-1,2,"fMCMCStatistics_AllChains=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fCorrectRValueForSamplingVariability=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fMCMCRValueParametersCriterion=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fMCMCRValueParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TRandom3),-1,-1,2,"fRandom=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,2,"fH1Marginalized=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<TH2*> >"),-1,2,"fH2Marginalized=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR),G__defined_typename("vector<std::pair<int,int> >"),-1,2,"fRequestedH2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TTree),-1,-1,2,"fMCMCTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fMCMCTreeLoaded=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fMCMCTreeReuseObservables=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLChainState),-1,-1,2,"fMCMCTree_State=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fMCMCTree_Chain=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_TTree),-1,-1,2,"fParameterTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fLocalModes=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D),-1,-1,2,"fBCH1DdrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D),-1,-1,2,"fBCH2DdrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fRescaleHistogramRangesAfterPreRun=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fHistogramRescalePadding=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCTrashlETObjectgR),-1,-1,2,"fObjectTrash=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCModel */
static void G__setup_memvarBCModel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel));
   { BCModel *p; p=(BCModel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet),-1,-1,2,"fDataSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel),-1,-1,2,"fPriorModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D),-1,-1,2,"fBCH1DPriorDrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D),-1,-1,2,"fBCH2DPriorDrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D),-1,-1,2,"fBCH1DPosteriorDrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D),-1,-1,2,"fBCH2DPosteriorDrawingOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fDrawPriorFirst=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFactorizedPrior=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCIntegrate */
static void G__setup_memvarBCIntegrate(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate));
   { BCIntegrate *p; p=(BCIntegrate*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kOptEmpty=%lldLL",(long long)BCIntegrate::kOptEmpty).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kOptSimAnn=%lldLL",(long long)BCIntegrate::kOptSimAnn).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kOptMetropolis=%lldLL",(long long)BCIntegrate::kOptMetropolis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kOptMinuit=%lldLL",(long long)BCIntegrate::kOptMinuit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kOptDefault=%lldLL",(long long)BCIntegrate::kOptDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-2,1,G__FastAllocString(2048).Format("NOptMethods=%lldLL",(long long)BCIntegrate::NOptMethods).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntEmpty=%lldLL",(long long)BCIntegrate::kIntEmpty).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntMonteCarlo=%lldLL",(long long)BCIntegrate::kIntMonteCarlo).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntCuba=%lldLL",(long long)BCIntegrate::kIntCuba).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntGrid=%lldLL",(long long)BCIntegrate::kIntGrid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntLaplace=%lldLL",(long long)BCIntegrate::kIntLaplace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("kIntDefault=%lldLL",(long long)BCIntegrate::kIntDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-2,1,G__FastAllocString(2048).Format("NIntMethods=%lldLL",(long long)BCIntegrate::NIntMethods).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kMargEmpty=%lldLL",(long long)BCIntegrate::kMargEmpty).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kMargMetropolis=%lldLL",(long long)BCIntegrate::kMargMetropolis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kMargMonteCarlo=%lldLL",(long long)BCIntegrate::kMargMonteCarlo).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kMargGrid=%lldLL",(long long)BCIntegrate::kMargGrid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("kMargDefault=%lldLL",(long long)BCIntegrate::kMargDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-2,1,G__FastAllocString(2048).Format("NMargMethods=%lldLL",(long long)BCIntegrate::NMargMethods).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule),-1,-2,1,G__FastAllocString(2048).Format("kSACauchy=%lldLL",(long long)BCIntegrate::kSACauchy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule),-1,-2,1,G__FastAllocString(2048).Format("kSABoltzmann=%lldLL",(long long)BCIntegrate::kSABoltzmann).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule),-1,-2,1,G__FastAllocString(2048).Format("kSACustom=%lldLL",(long long)BCIntegrate::kSACustom).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule),-1,-2,1,G__FastAllocString(2048).Format("NSAMethods=%lldLL",(long long)BCIntegrate::NSAMethods).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("kCubaVegas=%lldLL",(long long)BCIntegrate::kCubaVegas).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("kCubaSuave=%lldLL",(long long)BCIntegrate::kCubaSuave).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("kCubaDivonne=%lldLL",(long long)BCIntegrate::kCubaDivonne).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("kCubaCuhre=%lldLL",(long long)BCIntegrate::kCubaCuhre).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("kCubaDefault=%lldLL",(long long)BCIntegrate::kCubaDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-2,1,G__FastAllocString(2048).Format("NCubaMethods=%lldLL",(long long)BCIntegrate::NCubaMethods).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFlagIgnorePrevOptimization=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSAT0=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSATmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fSANIterations=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSATemperature=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fSALogProb=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fSAx=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fFlagMarginalized=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCMinimizercLcLWrapper),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-1,4,"fOptimizationMethodCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod),-1,-1,4,"fOptimizationMethodUsed=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-1,4,"fIntegrationMethodCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod),-1,-1,4,"fIntegrationMethodUsed=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-1,4,"fMarginalizationMethodCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod),-1,-1,4,"fMarginalizationMethodUsed=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule),-1,-1,4,"fSASchedule=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNIterationsMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNIterationsMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNIterationsPrecisionCheck=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNIterations=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fBestFitParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fBestFitParameterErrors=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLogMaximum=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fIntegral=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRelativePrecision=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fAbsolutePrecision=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fError=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod),-1,-1,4,"fCubaIntegrationMethod=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLVegas),-1,-1,4,"fCubaVegasOptions=",0,"/< CUBA Vegas options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLSuave),-1,-1,4,"fCubaSuaveOptions=",0,"/< CUBA Suave options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLDivonne),-1,-1,4,"fCubaDivonneOptions=",0,"/< CUBA Divonne options");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLCuhre),-1,-1,4,"fCubaCuhreOptions=",0,"/< CUBA Cuhre options");
   }
   G__tag_memvar_reset();
}


   /* BCPriorModel */
static void G__setup_memvarBCPriorModel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel));
   { BCPriorModel *p; p=(BCPriorModel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel),-1,-1,2,"fModel=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fCallLikelihood=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* BCEmptyModel */
static void G__setup_memvarBCEmptyModel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel));
   { BCEmptyModel *p; p=(BCEmptyModel*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* BCModelManager */
static void G__setup_memvarBCModelManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModelManager));
   { BCModelManager *p; p=(BCModelManager*)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,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR),G__defined_typename("vector<BCModel*>"),-1,4,"fModels=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fAPrioriProbability=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fAPosterioriProbability=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet),-1,-1,4,"fDataSet=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncBCHistogramBase(void) {
   /* BCHistogramBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase));
   G__memfunc_setup("BCHistogramBase",1454,G__libBAT_rdict_215_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 50 '0' hist i - - 0 '0' dimension", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCHistogramBase",1454,G__libBAT_rdict_215_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase), -1, 0, 1, 1, 1, 0, "u 'BCHistogramBase' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_215_0_3, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase), -1, 1, 1, 1, 1, 0, "u 'BCHistogramBase' - 0 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_215_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase), -1, 1, 1, 1, 1, 0, "U 'TH1' - 50 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_215_0_5, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCHistogramBase), -1, 1, 1, 1, 1, 0, "u 'TH1' - 11 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogram",1230,G__libBAT_rdict_215_0_6, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDimension",1222,G__libBAT_rdict_215_0_7, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLegend",879,G__libBAT_rdict_215_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TLegend), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNLegendColumns",1694,G__libBAT_rdict_215_0_9, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__libBAT_rdict_215_0_10, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__libBAT_rdict_215_0_11, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__libBAT_rdict_215_0_12, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalMode",1168,G__libBAT_rdict_215_0_13, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalMode",1168,G__libBAT_rdict_215_0_14, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalMode",1168,G__libBAT_rdict_215_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBandColor",1172,G__libBAT_rdict_215_0_16, 105, -1, -1, 0, 1, 1, 1, 8, "i - - 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBandOvercoverage",1917,G__libBAT_rdict_215_0_17, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineColor",1191,G__libBAT_rdict_215_0_18, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineStyle",1209,G__libBAT_rdict_215_0_19, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineWidth",1192,G__libBAT_rdict_215_0_20, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkerColor",1409,G__libBAT_rdict_215_0_21, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkerScale",1386,G__libBAT_rdict_215_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBandFillStyle",1581,G__libBAT_rdict_215_0_23, 115, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBands",854,G__libBAT_rdict_215_0_24, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSmooth",1000,G__libBAT_rdict_215_0_25, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawGlobalMode",1668,G__libBAT_rdict_215_0_26, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawGlobalModeArrows",2306,G__libBAT_rdict_215_0_27, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParametersMarkerStyle",3160,G__libBAT_rdict_215_0_28, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawLocalMode",1566,G__libBAT_rdict_215_0_29, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawLocalModeArrows",2204,G__libBAT_rdict_215_0_30, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalModeMarkerStyle",2307,G__libBAT_rdict_215_0_31, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawMean",1071,G__libBAT_rdict_215_0_32, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMeanMarkerStyle",1812,G__libBAT_rdict_215_0_33, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawStandardDeviation",2434,G__libBAT_rdict_215_0_34, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogx",698,G__libBAT_rdict_215_0_35, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogy",699,G__libBAT_rdict_215_0_36, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogz",700,G__libBAT_rdict_215_0_37, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridx",798,G__libBAT_rdict_215_0_38, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridy",799,G__libBAT_rdict_215_0_39, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntervals",1240,G__libBAT_rdict_215_0_40, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntervals",1240,G__libBAT_rdict_215_0_41, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetROOToptions",1392,G__libBAT_rdict_215_0_42, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetROOToptions",1392,G__libBAT_rdict_215_0_43, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyOptions",1159,G__libBAT_rdict_215_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCHistogramBase' - 11 - other", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalMode",1282,G__libBAT_rdict_215_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 - gm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnsetGlobalMode",1509,G__libBAT_rdict_215_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalMode",1282,G__libBAT_rdict_215_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - lm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalMode",1180,G__libBAT_rdict_215_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 - lm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnsetLocalMode",1407,G__libBAT_rdict_215_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalMode",1180,G__libBAT_rdict_215_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - lm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorScheme",1408,G__libBAT_rdict_215_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCHistogramBase::BCHColorScheme' - 0 - scheme", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBandColor",1149,G__libBAT_rdict_215_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBandColor",1184,G__libBAT_rdict_215_0_53, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBandOvercoverage",1929,G__libBAT_rdict_215_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineColor",1203,G__libBAT_rdict_215_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineStyle",1221,G__libBAT_rdict_215_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineWidth",1204,G__libBAT_rdict_215_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerColor",1421,G__libBAT_rdict_215_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerScale",1398,G__libBAT_rdict_215_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBandFillStyle",1593,G__libBAT_rdict_215_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "s - - 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistogram",1242,G__libBAT_rdict_215_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 50 - hist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLogx",710,G__libBAT_rdict_215_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogy",711,G__libBAT_rdict_215_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogz",712,G__libBAT_rdict_215_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridx",810,G__libBAT_rdict_215_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridy",811,G__libBAT_rdict_215_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBands",866,G__libBAT_rdict_215_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSmooth",1012,G__libBAT_rdict_215_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawGlobalMode",1680,G__libBAT_rdict_215_0_69, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' flag g - - 0 'true' arrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalModeMarkerStyle",2421,G__libBAT_rdict_215_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawLocalMode",1578,G__libBAT_rdict_215_0_71, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' flag g - - 0 'true' arrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalModeMarkerStyle",2319,G__libBAT_rdict_215_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawMean",1083,G__libBAT_rdict_215_0_73, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' flag g - - 0 'true' stddev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMeanMarkerStyle",1824,G__libBAT_rdict_215_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawLegend",1289,G__libBAT_rdict_215_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNLegendColumns",1706,G__libBAT_rdict_215_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStats",827,G__libBAT_rdict_215_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIntervals",1252,G__libBAT_rdict_215_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 - intervals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInterval",1137,G__libBAT_rdict_215_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - interval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInterval",1102,G__libBAT_rdict_215_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - interval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetROOToptions",1404,G__libBAT_rdict_215_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Valid",496,G__libBAT_rdict_215_0_82, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearBandColors",1486,G__libBAT_rdict_215_0_83, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearIntervals",1439,G__libBAT_rdict_215_0_84, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Smooth",634,G__libBAT_rdict_215_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 '-1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,G__libBAT_rdict_215_0_86, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBands",886,G__libBAT_rdict_215_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMarkers",1123,G__libBAT_rdict_215_0_88, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawGlobalMode",1380,G__libBAT_rdict_215_0_89, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLocalMode",1278,G__libBAT_rdict_215_0_90, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMean",783,G__libBAT_rdict_215_0_91, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeLegend",1217,G__libBAT_rdict_215_0_92, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawLegend",989,G__libBAT_rdict_215_0_93, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNonzeroBinDensityMassVector",3083,G__libBAT_rdict_215_0_94, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<pair<double,double>,allocator<pair<double,double> > >' 'vector<std::pair<double,double> >' 1 - bin_dens_mass i - - 0 '-1' sort", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmallestIntervalBounds",2581,G__libBAT_rdict_215_0_95, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR), G__defined_typename("vector<std::pair<double,double> >"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 0 - masses g - - 0 'true' overcoverage", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmallestIntervalSize",2373,G__libBAT_rdict_215_0_96, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 0 - masses g - - 0 'true' overcoverage", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSmallestIntervalSize",2373,G__libBAT_rdict_215_0_97, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - mass g - - 0 'true' overcoverage", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckIntervals",1430,G__libBAT_rdict_215_0_98, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - intervals i - - 0 - sort", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefaultIntervals",1661,G__libBAT_rdict_215_0_99, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 0, "i - - 0 '-1' nbands", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLegendEntry",1386,G__libBAT_rdict_215_0_100, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TLegendEntry), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj u 'string' - 11 - label "
"u 'string' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBandLegendEntry",1759,G__libBAT_rdict_215_0_101, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TLegendEntry), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj u 'string' - 11 - label "
"u 'string' - 11 - options", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCHistogramBase", 1580, G__libBAT_rdict_215_0_102, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCLog(void) {
   /* BCLog */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCLog));
   G__memfunc_setup("BCLog",423,G__libBAT_rdict_234_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCLog), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogLevelFile",1466,G__libBAT_rdict_234_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (BCLog::LogLevel (*)())(&BCLog::GetLogLevelFile) ), 0);
   G__memfunc_setup("GetLogLevelScreen",1690,G__libBAT_rdict_234_0_3, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCLogcLcLLogLevel), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (BCLog::LogLevel (*)())(&BCLog::GetLogLevelScreen) ), 0);
   G__memfunc_setup("GetPrefix",910,G__libBAT_rdict_234_0_4, 103, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (bool (*)())(&BCLog::GetPrefix) ), 0);
   G__memfunc_setup("SetLogLevelFile",1478,G__libBAT_rdict_234_0_5, 121, -1, -1, 0, 1, 3, 1, 0, "i 'BCLog::LogLevel' - 0 - loglevel", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel))(&BCLog::SetLogLevelFile) ), 0);
   G__memfunc_setup("SetLogLevelScreen",1702,G__libBAT_rdict_234_0_6, 121, -1, -1, 0, 1, 3, 1, 0, "i 'BCLog::LogLevel' - 0 - loglevel", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel))(&BCLog::SetLogLevelScreen) ), 0);
   G__memfunc_setup("SetLogLevel",1094,G__libBAT_rdict_234_0_7, 121, -1, -1, 0, 2, 3, 1, 0, 
"i 'BCLog::LogLevel' - 0 - loglevelfile i 'BCLog::LogLevel' - 0 - loglevelscreen", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel, BCLog::LogLevel))(&BCLog::SetLogLevel) ), 0);
   G__memfunc_setup("SetLogLevel",1094,G__libBAT_rdict_234_0_8, 121, -1, -1, 0, 1, 3, 1, 0, "i 'BCLog::LogLevel' - 0 - loglevel", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel))(&BCLog::SetLogLevel) ), 0);
   G__memfunc_setup("SetPrefix",922,G__libBAT_rdict_234_0_9, 121, -1, -1, 0, 1, 3, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) G__func2void( (void (*)(bool))(&BCLog::SetPrefix) ), 0);
   G__memfunc_setup("OpenLog",692,G__libBAT_rdict_234_0_10, 121, -1, -1, 0, 3, 3, 1, 0, 
"u 'string' - 11 '\"log.txt\"' filename i 'BCLog::LogLevel' - 0 'BCLog::debug' loglevelfile "
"i 'BCLog::LogLevel' - 0 'BCLog::summary' loglevelscreen", (char*)NULL, (void*) G__func2void( (void (*)(const string&, BCLog::LogLevel, BCLog::LogLevel))(&BCLog::OpenLog) ), 0);
   G__memfunc_setup("IsOpen",590,G__libBAT_rdict_234_0_11, 103, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (bool (*)())(&BCLog::IsOpen) ), 0);
   G__memfunc_setup("CloseLog",792,G__libBAT_rdict_234_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BCLog::CloseLog) ), 0);
   G__memfunc_setup("Out",312,G__libBAT_rdict_234_0_13, 121, -1, -1, 0, 3, 3, 1, 0, 
"i 'BCLog::LogLevel' - 0 - loglevelfile i 'BCLog::LogLevel' - 0 - loglevelscreen "
"u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel, BCLog::LogLevel, const string&))(&BCLog::Out) ), 0);
   G__memfunc_setup("Out",312,G__libBAT_rdict_234_0_14, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::Out) ), 0);
   G__memfunc_setup("Out",312,G__libBAT_rdict_234_0_15, 121, -1, -1, 0, 2, 3, 1, 0, 
"i 'BCLog::LogLevel' - 0 - loglevel u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(BCLog::LogLevel, const string&))(&BCLog::Out) ), 0);
   G__memfunc_setup("OutError",834,G__libBAT_rdict_234_0_16, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::OutError) ), 0);
   G__memfunc_setup("OutWarning",1038,G__libBAT_rdict_234_0_17, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::OutWarning) ), 0);
   G__memfunc_setup("OutSummary",1062,G__libBAT_rdict_234_0_18, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::OutSummary) ), 0);
   G__memfunc_setup("OutDetail",907,G__libBAT_rdict_234_0_19, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::OutDetail) ), 0);
   G__memfunc_setup("OutDebug",799,G__libBAT_rdict_234_0_20, 121, -1, -1, 0, 1, 3, 1, 0, "u 'string' - 11 - message", (char*)NULL, (void*) G__func2void( (void (*)(const string&))(&BCLog::OutDebug) ), 0);
   G__memfunc_setup("StartupInfo",1151,G__libBAT_rdict_234_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BCLog::StartupInfo) ), 0);
   G__memfunc_setup("GetVersion",1030,G__libBAT_rdict_234_0_22, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const string& (*)())(&BCLog::GetVersion) ), 0);
   G__memfunc_setup("ToString",826,G__libBAT_rdict_234_0_23, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 3, 1, 0, "i 'BCLog::LogLevel' - 0 - -", (char*)NULL, (void*) G__func2void( (string (*)(BCLog::LogLevel))(&BCLog::ToString) ), 0);
   // automatic destructor
   G__memfunc_setup("~BCLog", 549, G__libBAT_rdict_234_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCMath(void) {
   /* BCMath */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCMath));
   G__memfunc_setup("LogGaus",690,G__libBAT_rdict_250_0_1, 100, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - x d - - 0 '0' mean "
"d - - 0 '1' sigma g - - 0 'false' norm", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double, bool))(&BCMath::LogGaus) ), 0);
   G__memfunc_setup("LogSplitGaus",1214,G__libBAT_rdict_250_0_2, 100, -1, -1, 0, 5, 1, 1, 0, 
"d - - 0 - x d - - 0 - mode "
"d - - 0 - sigma_below d - - 0 - sigma_above "
"g - - 0 'false' norm", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double, double, bool))(&BCMath::LogSplitGaus) ), 0);
   G__memfunc_setup("LogPoisson",1037,G__libBAT_rdict_250_0_3, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x d - - 0 - lambda", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&BCMath::LogPoisson) ), 0);
   G__memfunc_setup("LogApproxBinomial",1735,G__libBAT_rdict_250_0_4, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"d - - 0 - p", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int, double))(&BCMath::LogApproxBinomial) ), 0);
   G__memfunc_setup("LogBreitWignerNonRel",2002,G__libBAT_rdict_250_0_5, 100, -1, -1, 0, 4, 1, 1, 0, 
"d - - 0 - x d - - 0 - mean "
"d - - 0 - Gamma g - - 0 'false' norm", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double, bool))(&BCMath::LogBreitWignerNonRel) ), 0);
   G__memfunc_setup("LogBreitWignerRel",1703,G__libBAT_rdict_250_0_6, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - mean "
"d - - 0 - Gamma", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&BCMath::LogBreitWignerRel) ), 0);
   G__memfunc_setup("LogChi2",616,G__libBAT_rdict_250_0_7, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x i - - 0 - n", (char*)NULL, (void*) G__func2void( (double (*)(double, int))(&BCMath::LogChi2) ), 0);
   G__memfunc_setup("LogVoigtian",1123,G__libBAT_rdict_250_0_8, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - sigma "
"d - - 0 - gamma", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&BCMath::LogVoigtian) ), 0);
   G__memfunc_setup("LogGammaPDF",991,G__libBAT_rdict_250_0_9, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - alpha "
"d - - 0 - beta", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&BCMath::LogGammaPDF) ), 0);
   G__memfunc_setup("LogLogNormal",1197,G__libBAT_rdict_250_0_10, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 '0' mean "
"d - - 0 '1' sigma", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&BCMath::LogLogNormal) ), 0);
   G__memfunc_setup("ApproxBinomial",1445,G__libBAT_rdict_250_0_11, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"d - - 0 - p", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int, double))(&BCMath::ApproxBinomial) ), 0);
   G__memfunc_setup("LogBinomFactor",1398,G__libBAT_rdict_250_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int))(&BCMath::LogBinomFactor) ), 0);
   G__memfunc_setup("ApproxLogFact",1306,G__libBAT_rdict_250_0_13, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&BCMath::ApproxLogFact) ), 0);
   G__memfunc_setup("LogBinomFactorExact",1899,G__libBAT_rdict_250_0_14, 100, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int))(&BCMath::LogBinomFactorExact) ), 0);
   G__memfunc_setup("LogFact",672,G__libBAT_rdict_250_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int))(&BCMath::LogFact) ), 0);
   G__memfunc_setup("CacheFactorials",1500,G__libBAT_rdict_250_0_16, 104, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) G__func2void( (unsigned int (*)(unsigned int))(&BCMath::CacheFactorials) ), 0);
   G__memfunc_setup("Nint",409,G__libBAT_rdict_250_0_17, 105, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (int (*)(double))(&BCMath::Nint) ), 0);
   G__memfunc_setup("CorrectPValue",1311,G__libBAT_rdict_250_0_18, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 11 - pvalue h - - 11 - npar "
"h - - 11 - nobservations", (char*)NULL, (void*) G__func2void( (double (*)(const double&, const unsigned int&, const unsigned int&))(&BCMath::CorrectPValue) ), 0);
   G__memfunc_setup("FastPValue",987,G__libBAT_rdict_250_0_19, 100, -1, -1, 0, 4, 1, 1, 0, 
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<unsigned>' 11 - observed u 'vector<double,allocator<double> >' 'vector<double>' 11 - expected "
"h - - 0 '1e5' - h - - 0 '0' -", (char*)NULL, (void*) G__func2void( (double (*)(const vector<unsigned>&, const vector<double>&, unsigned int, unsigned int))(&BCMath::FastPValue) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCVariable(void) {
   /* BCVariable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable));
   G__memfunc_setup("BCVariable",939,G__libBAT_rdict_254_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCVariable",939,G__libBAT_rdict_254_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - lowerlimit "
"d - - 0 - upperlimit u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrefix",910,G__libBAT_rdict_254_0_3, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,G__libBAT_rdict_254_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSafeName",1056,G__libBAT_rdict_254_0_5, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLatexName",1183,G__libBAT_rdict_254_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUnitString",1335,G__libBAT_rdict_254_0_7, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLatexNameWithUnits",2126,G__libBAT_rdict_254_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLowerLimit",1320,G__libBAT_rdict_254_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUpperLimit",1323,G__libBAT_rdict_254_0_10, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRangeWidth",1293,G__libBAT_rdict_254_0_11, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRangeCenter",1390,G__libBAT_rdict_254_0_12, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrecision",1228,G__libBAT_rdict_254_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH1",512,G__libBAT_rdict_254_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH2",513,G__libBAT_rdict_254_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbins",794,G__libBAT_rdict_254_0_16, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,G__libBAT_rdict_254_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLatexName",1195,G__libBAT_rdict_254_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - latex_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUnitString",1347,G__libBAT_rdict_254_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - unit_string", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLowerLimit",1332,G__libBAT_rdict_254_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - limit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUpperLimit",1335,G__libBAT_rdict_254_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - limit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimits",926,G__libBAT_rdict_254_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '0' lowerlimit d - - 0 '1' upperlimit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_254_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistograms",1448,G__libBAT_rdict_254_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistograms",1448,G__libBAT_rdict_254_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 - fill_1d g - - 0 - fill_2d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH1",512,G__libBAT_rdict_254_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH2",513,G__libBAT_rdict_254_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNbins",806,G__libBAT_rdict_254_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsNamed",673,G__libBAT_rdict_254_0_29, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSafeNamed",1056,G__libBAT_rdict_254_0_30, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - safename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PositionInRange",1529,G__libBAT_rdict_254_0_31, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ValueFromPositionInRange",2442,G__libBAT_rdict_254_0_32, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculatePrecision",1850,G__libBAT_rdict_254_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'false' force", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAtLimit",880,G__libBAT_rdict_254_0_34, 103, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWithinLimits",1441,G__libBAT_rdict_254_0_35, 103, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_254_0_36, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OneLineSummary",1432,G__libBAT_rdict_254_0_37, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 2, 1, 1, 8, 
"g - - 0 'true' print_prefix i - - 0 '-1' name_length", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("H1Title",635,G__libBAT_rdict_254_0_38, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("H2Title",636,G__libBAT_rdict_254_0_39, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 8, "u 'BCVariable' - 11 - ordinate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("H3Title",637,G__libBAT_rdict_254_0_40, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 2, 1, 1, 8, 
"u 'BCVariable' - 11 - ordinate_y u 'BCVariable' - 11 - ordinate_z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateH1",717,G__libBAT_rdict_254_0_41, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateH2",718,G__libBAT_rdict_254_0_42, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 2, 1, 1, 8, 
"u 'string' - 11 - name u 'BCVariable' - 11 - ordinate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateH3",719,G__libBAT_rdict_254_0_43, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH3), -1, 0, 3, 1, 1, 8, 
"u 'string' - 11 - name u 'BCVariable' - 11 - ordinate_y "
"u 'BCVariable' - 11 - ordinate_z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUniformRandomValue",2142,G__libBAT_rdict_254_0_44, 100, -1, -1, 0, 1, 1, 1, 8, "U 'TRandom' - 40 - R", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("BCVariable", 939, G__libBAT_rdict_254_0_45, (int) ('i'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 0, 1, 1, 1, 0, "u 'BCVariable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCVariable", 1065, G__libBAT_rdict_254_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__libBAT_rdict_254_0_47, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 1, 1, 1, 1, 0, "u 'BCVariable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCDataPoint(void) {
   /* BCDataPoint */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint));
   G__memfunc_setup("BCDataPoint",1033,G__libBAT_rdict_255_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 0, 1, 1, 1, 0, "i - - 0 '0' nvariables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCDataPoint",1033,G__libBAT_rdict_255_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_255_0_3, 100, -1, -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_255_0_4, 100, -1, -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__libBAT_rdict_255_0_5, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__libBAT_rdict_255_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__libBAT_rdict_255_0_7, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNValues",990,G__libBAT_rdict_255_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__libBAT_rdict_255_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValues",924,G__libBAT_rdict_255_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNValues",1002,G__libBAT_rdict_255_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 '0.' val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_255_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "1 - 'void (*)(const std::string&) ' 0 'BCLog::OutSummary' output", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("BCDataPoint", 1033, G__libBAT_rdict_255_0_13, (int) ('i'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 0, 1, 1, 1, 0, "u 'BCDataPoint' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCDataPoint", 1159, G__libBAT_rdict_255_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__libBAT_rdict_255_0_15, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 1, 1, 1, 0, "u 'BCDataPoint' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCDataSet(void) {
   /* BCDataSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet));
   G__memfunc_setup("BCDataSet",811,G__libBAT_rdict_259_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet), -1, 0, 1, 1, 1, 0, "h - - 0 '0' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_259_0_2, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_259_0_3, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDataPoints",1381,G__libBAT_rdict_259_0_4, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNValuesPerPoint",1807,G__libBAT_rdict_259_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPoint",1188,G__libBAT_rdict_259_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPoint",1188,G__libBAT_rdict_259_0_7, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Back",369,G__libBAT_rdict_259_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataComponents",1728,G__libBAT_rdict_259_0_9, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoundsExist",1144,G__libBAT_rdict_259_0_10, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerBounds",1428,G__libBAT_rdict_259_0_11, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperBounds",1431,G__libBAT_rdict_259_0_12, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserLowerBounds",1843,G__libBAT_rdict_259_0_13, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserUpperBounds",1846,G__libBAT_rdict_259_0_14, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataPoint), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowerBound",1313,G__libBAT_rdict_259_0_15, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpperBound",1316,G__libBAT_rdict_259_0_16, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRangeWidth",1293,G__libBAT_rdict_259_0_17, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFixed",684,G__libBAT_rdict_259_0_18, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNValuesPerPoint",1819,G__libBAT_rdict_259_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBounds",919,G__libBAT_rdict_259_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - - d - - 0 - lower_bound "
"d - - 0 - upper_bound g - - 0 'false' fixed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__libBAT_rdict_259_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - g - - 0 'true' b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDataFromFile",1546,G__libBAT_rdict_259_0_22, 103, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 - treename "
"u 'string' - 11 - branchnames c - - 0 '','' delim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDataFromFile",1546,G__libBAT_rdict_259_0_23, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - filename i - - 0 - nvariables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDataFromFileTree",1946,G__libBAT_rdict_259_0_24, 103, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 - treename "
"u 'string' - 11 - branchnames c - - 0 '','' delim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDataFromFileTxt",1866,G__libBAT_rdict_259_0_25, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - filename i - - 0 - nvariables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDataPoint",1165,G__libBAT_rdict_259_0_26, 103, -1, -1, 0, 1, 1, 1, 0, "u 'BCDataPoint' - 11 - datapoint", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustBoundForUncertainties",2792,G__libBAT_rdict_259_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - - d - - 0 - nSigma "
"h - - 0 - - i - - 0 '-1' i_err2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__libBAT_rdict_259_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_259_0_29, 121, -1, -1, 0, 1, 1, 1, 8, "1 - 'void (*)(const std::string&) ' 0 'BCLog::OutSummary' output", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraph",786,G__libBAT_rdict_259_0_30, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TGraph), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraph",786,G__libBAT_rdict_259_0_31, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TGraphErrors), -1, 0, 4, 1, 1, 8, 
"h - - 0 - - h - - 0 - - "
"i - - 0 - ex i - - 0 - ey", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraph",786,G__libBAT_rdict_259_0_32, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TGraphAsymmErrors), -1, 0, 6, 1, 1, 8, 
"h - - 0 - - h - - 0 - - "
"i - - 0 - ex_below i - - 0 - ex_above "
"i - - 0 - ey_below i - - 0 - ey_above", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateH2",718,G__libBAT_rdict_259_0_33, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 8, 1, 1, 8, 
"C - - 10 - name C - - 10 - title "
"h - - 0 - - h - - 0 - - "
"h - - 0 '100' - h - - 0 '100' - "
"d - - 0 '0.10' x_padding d - - 0 '0.10' y_padding", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("BCDataSet", 811, G__libBAT_rdict_259_0_34, (int) ('i'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet), -1, 0, 1, 1, 1, 0, "u 'BCDataSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCDataSet", 937, G__libBAT_rdict_259_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__libBAT_rdict_259_0_36, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet), -1, 1, 1, 1, 1, 0, "u 'BCDataSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCH1D(void) {
   /* BCH1D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D));
   G__memfunc_setup("BCH1D",322,G__libBAT_rdict_264_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 1, 1, 1, 0, "U 'TH1' - 50 '0' hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCH1D",322,G__libBAT_rdict_264_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 1, 1, 1, 0, "u 'BCH1D' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLocalMode",1168,G__libBAT_rdict_264_0_3, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__libBAT_rdict_264_0_4, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedian",878,G__libBAT_rdict_264_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQuantile",1123,G__libBAT_rdict_264_0_6, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - probability", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimit",799,G__libBAT_rdict_264_0_7, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - probability", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBandType",1079,G__libBAT_rdict_264_0_8, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNQuantiles",1316,G__libBAT_rdict_264_0_9, 104, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetQuantileLineColor",2026,G__libBAT_rdict_264_0_10, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawMedian",1276,G__libBAT_rdict_264_0_11, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawCentral68",1509,G__libBAT_rdict_264_0_12, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyOptions",1159,G__libBAT_rdict_264_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCH1D' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorScheme",1408,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i 'BCHistogramBase::BCHColorScheme' - 0 - scheme", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetGlobalMode",1282,G__libBAT_rdict_264_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalMode",1180,G__libBAT_rdict_264_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBandType",1091,G__libBAT_rdict_264_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCH1D::BCH1DBandType' - 0 - bt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawQuantiles",1648,G__libBAT_rdict_264_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetQuantileLineColor",2038,G__libBAT_rdict_264_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawMedian",1288,G__libBAT_rdict_264_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' flag g - - 0 'true' central68", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckIntervals",1430,G__libBAT_rdict_264_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - intervals", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefaultIntervals",1661,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 0, "i - - 0 '-1' nbands", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBands",886,G__libBAT_rdict_264_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 '\"same\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMarkers",1123,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawQuantiles",1348,G__libBAT_rdict_264_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMedian",988,G__libBAT_rdict_264_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_264_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 '\"\"' prefix h - - 0 '6' - "
"u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>(0)' intervals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmallestIntervals",2077,G__libBAT_rdict_264_0_28, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR), G__defined_typename("vector<BCH1D::BCH1DSmallestInterval>"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 - masses", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmallestIntervals",2077,G__libBAT_rdict_264_0_29, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1DcLcLBCH1DSmallestInterval), -1, 0, 1, 1, 1, 0, "d - - 0 - mass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubHistogram",1528,G__libBAT_rdict_264_0_30, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 4, 1, 1, 0, 
"d - - 0 - min d - - 0 - max "
"u 'string' - 11 '\"\"' name g - - 0 'false' preserve_range", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCH1D", 448, G__libBAT_rdict_264_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCH2D(void) {
   /* BCH2D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D));
   G__memfunc_setup("BCH2D",323,G__libBAT_rdict_276_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 1, 1, 1, 0, "U 'TH2' - 50 '0' h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCH2D",323,G__libBAT_rdict_276_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 1, 1, 1, 0, "u 'BCH2D' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogram",1230,G__libBAT_rdict_276_0_3, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBandType",1079,G__libBAT_rdict_276_0_4, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogz",700,G__libBAT_rdict_276_0_5, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawProfileX",1495,G__libBAT_rdict_276_0_6, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileXType",1515,G__libBAT_rdict_276_0_7, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileXLineColor",2000,G__libBAT_rdict_276_0_8, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileXLineStyle",2018,G__libBAT_rdict_276_0_9, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawProfileY",1496,G__libBAT_rdict_276_0_10, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileYType",1516,G__libBAT_rdict_276_0_11, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileYLineColor",2001,G__libBAT_rdict_276_0_12, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProfileYLineStyle",2019,G__libBAT_rdict_276_0_13, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyOptions",1159,G__libBAT_rdict_276_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCH2D' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGlobalMode",1282,G__libBAT_rdict_276_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLocalMode",1180,G__libBAT_rdict_276_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBandType",1091,G__libBAT_rdict_276_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCH2D::BCH2DBandType' - 0 - bt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogz",712,G__libBAT_rdict_276_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawProfileX",1507,G__libBAT_rdict_276_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileXType",1527,G__libBAT_rdict_276_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCH2D::BCH2DProfileType' - 0 - pt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileXLineColor",2012,G__libBAT_rdict_276_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileXLineStyle",2030,G__libBAT_rdict_276_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawProfileY",1508,G__libBAT_rdict_276_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileYType",1528,G__libBAT_rdict_276_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCH2D::BCH2DProfileType' - 0 - pt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileYLineColor",2013,G__libBAT_rdict_276_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProfileYLineStyle",2031,G__libBAT_rdict_276_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckIntervals",1430,G__libBAT_rdict_276_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - intervals", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefaultIntervals",1661,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 0, "i - - 0 '-1' nbands", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawBands",886,G__libBAT_rdict_276_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 '\"same\"' options", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawMarkers",1123,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateProfileGraph",2129,G__libBAT_rdict_276_0_31, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TGraph), -1, 0, 2, 1, 1, 0, 
"i 'BCH2D::BCH2DProfileAxis' - 0 - axis i 'BCH2D::BCH2DProfileType' - 0 'kProfileMean' pt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProfileGraphs",1732,G__libBAT_rdict_276_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCH2D", 449, G__libBAT_rdict_276_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCPrior(void) {
   /* BCPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior));
   G__memfunc_setup("GetLogPrior",1102,G__libBAT_rdict_280_0_3, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Clone",497,G__libBAT_rdict_280_0_4, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsValid",684,G__libBAT_rdict_280_0_5, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLogNormalizedPrior",2147,G__libBAT_rdict_280_0_6, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_280_0_7, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x g - - 0 'false' normalize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunction",1126,G__libBAT_rdict_280_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TF1), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFunction",1126,G__libBAT_rdict_280_0_9, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TF1), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunctionRange",1631,G__libBAT_rdict_280_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,G__libBAT_rdict_280_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,G__libBAT_rdict_280_0_12, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,G__libBAT_rdict_280_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCentralMoment",1625,G__libBAT_rdict_280_0_14, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStandardizedMoment",2157,G__libBAT_rdict_280_0_15, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMean",673,G__libBAT_rdict_280_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVariance",1097,G__libBAT_rdict_280_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStandardDeviation",2036,G__libBAT_rdict_280_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSkewness",1139,G__libBAT_rdict_280_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKurtosis",1156,G__libBAT_rdict_280_0_20, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandomValue",1406,G__libBAT_rdict_280_0_21, 100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax "
"U 'TRandom' - 40 '0' R", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPriorForROOT",1431,G__libBAT_rdict_280_0_22, 100, -1, -1, 0, 2, 1, 1, 0, 
"D - - 0 - x D - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNormalizedPriorForROOT",2476,G__libBAT_rdict_280_0_23, 100, -1, -1, 0, 2, 1, 1, 0, 
"D - - 0 - x D - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPriorForROOT",1721,G__libBAT_rdict_280_0_24, 100, -1, -1, 0, 2, 1, 1, 0, 
"D - - 0 - x D - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNormalizedLogPriorForROOT",2766,G__libBAT_rdict_280_0_25, 100, -1, -1, 0, 2, 1, 1, 0, 
"D - - 0 - x D - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateAndStoreIntegral",2532,G__libBAT_rdict_280_0_26, 100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StoreIntegral",1347,G__libBAT_rdict_280_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - I", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StoreLogIntegral",1637,G__libBAT_rdict_280_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - logI", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStoredIntegral",1735,G__libBAT_rdict_280_0_29, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStoredLogIntegral",2025,G__libBAT_rdict_280_0_30, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistogramByCenterValue",2638,G__libBAT_rdict_280_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistogramByIntegral",2342,G__libBAT_rdict_280_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBCH1D",610,G__libBAT_rdict_280_0_33, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - bins u 'string' - 11 '\"prior\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBCH2D",611,G__libBAT_rdict_280_0_34, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 3, 1, 1, 0, 
"U 'BCPrior' - 0 - ordinate U 'TH2' - 0 - bins "
"u 'string' - 11 '\"prior\"' name", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCPrior", 783, G__libBAT_rdict_280_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCParameter(void) {
   /* BCParameter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter));
   G__memfunc_setup("BCParameter",1062,G__libBAT_rdict_281_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCParameter",1062,G__libBAT_rdict_281_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 0, 1, 1, 1, 0, "u 'BCParameter' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCParameter",1062,G__libBAT_rdict_281_0_3, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - lowerlimit "
"d - - 0 - upperlimit u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_281_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 1, 1, 1, 1, 0, "u 'BCParameter' - 0 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fixed",496,G__libBAT_rdict_281_0_5, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFixedValue",1293,G__libBAT_rdict_281_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_281_0_7, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_281_0_8, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_281_0_9, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,G__libBAT_rdict_281_0_10, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPriorMode",1201,G__libBAT_rdict_281_0_11, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPriorMean",1197,G__libBAT_rdict_281_0_12, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPriorVariance",1621,G__libBAT_rdict_281_0_13, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandomValueAccordingToPrior",3031,G__libBAT_rdict_281_0_14, 100, -1, -1, 0, 1, 1, 1, 8, "U 'TRandom' - 40 - rng", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimits",926,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '0' lowerlimit d - - 0 '1' upperlimit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fix",295,G__libBAT_rdict_281_0_16, 103, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Unfix",522,G__libBAT_rdict_281_0_17, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPrior",824,G__libBAT_rdict_281_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'BCPrior' - 40 - prior", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorConstant",1666,G__libBAT_rdict_281_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OneLineSummary",1432,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 2, 1, 1, 8, 
"g - - 0 'true' print_prefix i - - 0 '-1' name_length", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCParameter", 1188, G__libBAT_rdict_281_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCAux(void) {
   /* BCAux */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCAux));
   G__memfunc_setup("SetStyle",829,G__libBAT_rdict_314_0_1, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&BCAux::SetStyle) ), 0);
   G__memfunc_setup("DefaultToPDF",1122,G__libBAT_rdict_314_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 1 - filename", (char*)NULL, (void*) G__func2void( (void (*)(string&))(&BCAux::DefaultToPDF) ), 0);
   G__memfunc_setup("Transpose",959,G__libBAT_rdict_314_0_3, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 2, 1, 1, 0, 
"U 'TH2' - 50 - h u 'string' - 11 '\"\"' name", (char*)NULL, (void*) G__func2void( (TH2* (*)(const TH2 *const, const string&))(&BCAux::Transpose) ), 0);
   G__memfunc_setup("RangeType",911,G__libBAT_rdict_314_0_4, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCAuxcLcLBCRange), -1, 0, 2, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) G__func2void( (BCAux::BCRange (*)(double, double))(&BCAux::RangeType) ), 0);
   G__memfunc_setup("MakeFinite",989,G__libBAT_rdict_314_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 1 - xmin d - - 1 - xmax", (char*)NULL, (void*) G__func2void( (void (*)(double&, double&))(&BCAux::MakeFinite) ), 0);
   G__memfunc_setup("SafeName",768,G__libBAT_rdict_314_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) G__func2void( (string (*)(const string&))(&BCAux::SafeName) ), 0);
   G__memfunc_setup("AllowedCharacter",1621,G__libBAT_rdict_314_0_7, 103, -1, -1, 0, 1, 1, 1, 0, "c - - 0 - c", (char*)NULL, (void*) G__func2void( (bool (*)(char))(&BCAux::AllowedCharacter) ), 0);
   G__memfunc_setup("SetKnowledgeUpdateDrawingStyle",3084,G__libBAT_rdict_314_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'BCH1D' - 1 - prior u 'BCH1D' - 1 - posterior "
"i 'BCAux::BCKnowledgeUpdateDrawingStyle' - 0 'BCAux::kKnowledgeUpdateDefaultStyle' style", (char*)NULL, (void*) G__func2void( (void (*)(BCH1D&, BCH1D&, BCAux::BCKnowledgeUpdateDrawingStyle))(&BCAux::SetKnowledgeUpdateDrawingStyle) ), 0);
   G__memfunc_setup("SetKnowledgeUpdateDrawingStyle",3084,G__libBAT_rdict_314_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'BCH2D' - 1 - prior u 'BCH2D' - 1 - posterior "
"i 'BCAux::BCKnowledgeUpdateDrawingStyle' - 0 'BCAux::kKnowledgeUpdateDefaultStyle' style", (char*)NULL, (void*) G__func2void( (void (*)(BCH2D&, BCH2D&, BCAux::BCKnowledgeUpdateDrawingStyle))(&BCAux::SetKnowledgeUpdateDrawingStyle) ), 0);
   G__memfunc_setup("DrawKnowledgeUpdate",1937,G__libBAT_rdict_314_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'BCHistogramBase' - 1 - prior u 'BCHistogramBase' - 1 - posterior "
"g - - 0 - draw_prior_first u 'BCAux::BCTrash<TObject>' - 1 - trash", (char*)NULL, (void*) G__func2void( (void (*)(BCHistogramBase&, BCHistogramBase&, bool, BCAux::BCTrash<TObject>&))(&BCAux::DrawKnowledgeUpdate) ), 0);
   G__memfunc_setup("PrintPlots",1055,G__libBAT_rdict_314_0_11, 104, -1, -1, 0, 5, 1, 1, 0, 
"u 'vector<BCH1D,allocator<BCH1D> >' 'vector<BCH1D>' 1 - h1 u 'vector<BCH2D,allocator<BCH2D> >' 'vector<BCH2D>' 1 - h2 "
"u 'string' - 11 - filename h - - 0 '1' - "
"h - - 0 '1' -", (char*)NULL, (void*) G__func2void( (unsigned int (*)(vector<BCH1D>&, vector<BCH2D>&, const string&, unsigned int, unsigned int))(&BCAux::PrintPlots) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCConstantPrior(void) {
   /* BCConstantPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior));
   G__memfunc_setup("BCConstantPrior",1499,G__libBAT_rdict_346_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCConstantPrior",1499,G__libBAT_rdict_346_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior), -1, 0, 1, 1, 1, 0, "d - - 0 - range_width", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCConstantPrior",1499,G__libBAT_rdict_346_0_3, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCConstantPrior), -1, 0, 2, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandomValue",1406,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax "
"U 'TRandom' - 40 '0' R", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCConstantPrior", 1625, G__libBAT_rdict_346_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCGaussianPrior(void) {
   /* BCGaussianPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCGaussianPrior));
   G__memfunc_setup("BCGaussianPrior",1484,G__libBAT_rdict_347_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCGaussianPrior), -1, 0, 2, 1, 1, 0, 
"d - - 0 - mean d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMean",685,G__libBAT_rdict_347_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mean", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSigma",797,G__libBAT_rdict_347_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,G__libBAT_rdict_347_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - mean d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCGaussianPrior", 1610, G__libBAT_rdict_347_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCSplitGaussianPrior(void) {
   /* BCSplitGaussianPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior));
   G__memfunc_setup("BCSplitGaussianPrior",2008,G__libBAT_rdict_348_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior), -1, 0, 3, 1, 1, 0, 
"d - - 0 - mode d - - 0 - sigma_below "
"d - - 0 - sigma_above", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCSplitGaussianPrior",2008,G__libBAT_rdict_348_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCSplitGaussianPrior), -1, 0, 1, 1, 1, 0, "u 'BCSplitGaussianPrior' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMean",685,G__libBAT_rdict_348_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mean", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMode",689,G__libBAT_rdict_348_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSigmaBelow",1302,G__libBAT_rdict_348_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSigmaAbove",1290,G__libBAT_rdict_348_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,G__libBAT_rdict_348_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - mode d - - 0 - sigma_below "
"d - - 0 - sigma_above", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCSplitGaussianPrior", 2134, G__libBAT_rdict_348_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCCauchyPrior(void) {
   /* BCCauchyPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCCauchyPrior));
   G__memfunc_setup("BCCauchyPrior",1262,G__libBAT_rdict_349_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCCauchyPrior), -1, 0, 2, 1, 1, 0, 
"d - - 0 - mean d - - 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,G__libBAT_rdict_349_0_8, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMean",685,G__libBAT_rdict_349_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mean", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__libBAT_rdict_349_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - scale", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameters",1344,G__libBAT_rdict_349_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - mean d - - 0 - scale", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCCauchyPrior", 1388, G__libBAT_rdict_349_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCObservable(void) {
   /* BCObservable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable));
   G__memfunc_setup("BCObservable",1162,G__libBAT_rdict_350_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCObservable",1162,G__libBAT_rdict_350_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - lowerlimit "
"d - - 0 - upperlimit u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_350_0_3, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "d - - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__libBAT_rdict_350_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__libBAT_rdict_350_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("BCObservable", 1162, G__libBAT_rdict_350_0_6, (int) ('i'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 0, 1, 1, 1, 0, "u 'BCObservable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCObservable", 1288, G__libBAT_rdict_350_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__libBAT_rdict_350_0_8, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "u 'BCObservable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCVariableSetlEBCObservablegR(void) {
   /* BCVariableSet<BCObservable> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR));
   G__memfunc_setup("BCVariableSet<BCObservable>",2523,G__libBAT_rdict_351_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__libBAT_rdict_351_0_2, 103, -1, -1, 0, 1, 1, 1, 0, "u 'BCObservable' - 11 - var", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__libBAT_rdict_351_0_3, 103, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - min "
"d - - 0 - max u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_351_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__libBAT_rdict_351_0_5, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__libBAT_rdict_351_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("At",181,G__libBAT_rdict_351_0_7, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,G__libBAT_rdict_351_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Get",288,G__libBAT_rdict_351_0_9, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Back",369,G__libBAT_rdict_351_0_10, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Back",369,G__libBAT_rdict_351_0_11, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Index",504,G__libBAT_rdict_351_0_12, 104, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__libBAT_rdict_351_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Empty",527,G__libBAT_rdict_351_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNBins",774,G__libBAT_rdict_351_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_351_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistograms",1448,G__libBAT_rdict_351_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistograms",1448,G__libBAT_rdict_351_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 - flag_1d g - - 0 - flag_2d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH1",512,G__libBAT_rdict_351_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillH2",513,G__libBAT_rdict_351_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MaxNameLength",1289,G__libBAT_rdict_351_0_21, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Volume",632,G__libBAT_rdict_351_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWithinLimits",1441,G__libBAT_rdict_351_0_23, 103, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PositionInRange",1529,G__libBAT_rdict_351_0_24, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ValueFromPositionInRange",2442,G__libBAT_rdict_351_0_25, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRangeCenters",1505,G__libBAT_rdict_351_0_26, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUniformRandomValues",2257,G__libBAT_rdict_351_0_27, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "U 'TRandom' - 40 - R", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_351_0_28, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("BCVariableSet<BCObservable>", 2523, G__libBAT_rdict_351_0_29, (int) ('i'), 
G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR), -1, 0, 1, 1, 1, 0, "u 'BCVariableSet<BCObservable>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCVariableSet<BCObservable>", 2649, G__libBAT_rdict_351_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__libBAT_rdict_351_0_31, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR), -1, 1, 1, 1, 1, 0, "u 'BCVariableSet<BCObservable>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCTF1Prior(void) {
   /* BCTF1Prior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior));
   G__memfunc_setup("BCTF1Prior",860,G__libBAT_rdict_356_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior), -1, 0, 1, 1, 1, 0, "u 'TF1' - 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCTF1Prior",860,G__libBAT_rdict_356_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1Prior), -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - formula d - - 0 - xmin "
"d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x g - - 0 'false' normalize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCTF1Prior", 986, G__libBAT_rdict_356_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCTF1LogPrior(void) {
   /* BCTF1LogPrior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior));
   G__memfunc_setup("BCTF1LogPrior",1150,G__libBAT_rdict_357_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior), -1, 0, 1, 1, 1, 0, "u 'TF1' - 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCTF1LogPrior",1150,G__libBAT_rdict_357_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTF1LogPrior), -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - formula d - - 0 - xmin "
"d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunctionRange",1631,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogFunction",1416,G__libBAT_rdict_357_0_8, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TF1), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogFunction",1416,G__libBAT_rdict_357_0_9, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TF1), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCTF1LogPrior", 1276, G__libBAT_rdict_357_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCTH1Prior(void) {
   /* BCTH1Prior */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior));
   G__memfunc_setup("BCTH1Prior",862,G__libBAT_rdict_381_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior), -1, 0, 2, 1, 1, 0, 
"u 'TH1' - 1 - h g - - 0 'false' interpolate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCTH1Prior",862,G__libBAT_rdict_381_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - h g - - 0 'false' interpolate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCTH1Prior",862,G__libBAT_rdict_381_0_3, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior), -1, 0, 1, 1, 1, 0, "u 'BCTH1Prior' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_381_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCTH1Prior), -1, 1, 1, 1, 1, 0, "u 'BCTH1Prior' - 0 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPrior), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x g - - 0 'false' normalize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMode",677,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRawMoment",1210,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStandardizedMoment",2157,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 '-std::numeric_limits<double>::infinity()' xmin "
"d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVariance",1097,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStandardDeviation",2036,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 '-std::numeric_limits<double>::infinity()' xmin d - - 0 'std::numeric_limits<double>::infinity()' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBCH1D",610,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - bins u 'string' - 11 '\"prior\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInterpolate",1459,G__libBAT_rdict_381_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - interpolate", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandomValue",1406,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - xmin d - - 0 - xmax "
"U 'TRandom' - 40 '0' R", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__libBAT_rdict_381_0_18, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__libBAT_rdict_381_0_19, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInterpolate",1447,G__libBAT_rdict_381_0_20, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormalizeHistogram",1887,G__libBAT_rdict_381_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCTH1Prior", 988, G__libBAT_rdict_381_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCParameterSet(void) {
   /* BCParameterSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet));
   G__memfunc_setup("BCParameterSet",1362,G__libBAT_rdict_383_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNFixedParameters",1906,G__libBAT_rdict_383_0_2, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNFreeParameters",1796,G__libBAT_rdict_383_0_3, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Volume",632,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ArePriorsSet",1219,G__libBAT_rdict_383_0_5, 103, -1, -1, 0, 1, 1, 1, 8, "g - - 0 'true' ignore_fixed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsWithinLimits",1441,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAtFixedValues",1489,G__libBAT_rdict_383_0_7, 103, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ValueFromPositionInRange",2442,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRangeCenters",1505,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUniformRandomValues",2257,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "U 'TRandom' - 40 - R", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRandomValuesAccordingToPriors",3261,G__libBAT_rdict_383_0_11, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "U 'TRandom' - 40 - R", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPriorConstantAll",1947,G__libBAT_rdict_383_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogPrior",1102,G__libBAT_rdict_383_0_13, 100, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFixedValues",1408,G__libBAT_rdict_383_0_14, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "g - - 0 'true' include_unfixed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ApplyFixedValues",1638,G__libBAT_rdict_383_0_15, 103, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - x", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("BCParameterSet", 1362, G__libBAT_rdict_383_0_16, (int) ('i'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet), -1, 0, 1, 1, 1, 0, "u 'BCParameterSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCParameterSet", 1488, G__libBAT_rdict_383_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__libBAT_rdict_383_0_18, (int) ('u'), G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet), -1, 1, 1, 1, 1, 0, "u 'BCParameterSet' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCEngineMCMC(void) {
   /* BCEngineMCMC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC));
   G__memfunc_setup("operator=",937,G__libBAT_rdict_453_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMC), -1, 1, 1, 1, 1, 0, "u 'BCEngineMCMC' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__libBAT_rdict_453_0_5, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSafeName",1056,G__libBAT_rdict_453_0_6, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNChains",964,G__libBAT_rdict_453_0_7, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNLag",642,G__libBAT_rdict_453_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentIteration",1970,G__libBAT_rdict_453_0_9, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentChain",1510,G__libBAT_rdict_453_0_10, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsConvergenceGlobal",3152,G__libBAT_rdict_453_0_11, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsPreRun",2028,G__libBAT_rdict_453_0_12, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsPreRunMin",2320,G__libBAT_rdict_453_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsPreRunMax",2322,G__libBAT_rdict_453_0_14, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsRun",1733,G__libBAT_rdict_453_0_15, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsPreRunCheck",2506,G__libBAT_rdict_453_0_16, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreRunCheckClear",1857,G__libBAT_rdict_453_0_17, 104, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinimumEfficiency",2033,G__libBAT_rdict_453_0_18, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximumEfficiency",2035,G__libBAT_rdict_453_0_19, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleFactorLowerLimit",2415,G__libBAT_rdict_453_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleFactorUpperLimit",2418,G__libBAT_rdict_453_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleFactors",1498,G__libBAT_rdict_453_0_22, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR), G__defined_typename("vector<std::vector<double> >"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChainState",1284,G__libBAT_rdict_453_0_23, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLChainState), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Getx",408,G__libBAT_rdict_453_0_24, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Getx",408,G__libBAT_rdict_453_0_25, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogProbx",1101,G__libBAT_rdict_453_0_26, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhase",785,G__libBAT_rdict_453_0_27, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitialPositionScheme",2452,G__libBAT_rdict_453_0_28, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitialPositionAttemptLimit",3101,G__libBAT_rdict_453_0_29, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposeMultivariate",2303,G__libBAT_rdict_453_0_30, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposalFunctionDof",2255,G__libBAT_rdict_453_0_31, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultivariateCovarianceUpdates",3304,G__libBAT_rdict_453_0_32, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultivariateCovarianceUpdateLambda",3766,G__libBAT_rdict_453_0_33, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultivariateEpsilon",2289,G__libBAT_rdict_453_0_34, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMultivariateScaleMultiplier",3110,G__libBAT_rdict_453_0_35, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRValueParametersCriterion",2866,G__libBAT_rdict_453_0_36, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRValueParameters",1923,G__libBAT_rdict_453_0_37, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRValueParameters",1923,G__libBAT_rdict_453_0_38, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrectRValueForSamplingVariability",3875,G__libBAT_rdict_453_0_39, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFlagRun",975,G__libBAT_rdict_453_0_40, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkovChainTree",1795,G__libBAT_rdict_453_0_41, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameterTree",1617,G__libBAT_rdict_453_0_42, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutputFile",1329,G__libBAT_rdict_453_0_43, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatistics",1355,G__libBAT_rdict_453_0_44, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatistics",1355,G__libBAT_rdict_453_0_45, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatisticsVector",1982,G__libBAT_rdict_453_0_46, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR), G__defined_typename("vector<BCEngineMCMC::Statistics>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRescaleHistogramRangesAfterPreRun",3643,G__libBAT_rdict_453_0_47, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistogramRescalePadding",2628,G__libBAT_rdict_453_0_48, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetH1DPrintOrder",1510,G__libBAT_rdict_453_0_49, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetH2DPrintOrder",1511,G__libBAT_rdict_453_0_50, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR), G__defined_typename("vector<std::pair<unsigned,unsigned> >"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarginalizedHistogramExists",2821,G__libBAT_rdict_453_0_51, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarginalizedHistogramExists",2821,G__libBAT_rdict_453_0_52, 103, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalizedHistogram",2469,G__libBAT_rdict_453_0_53, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalizedHistogram",2469,G__libBAT_rdict_453_0_54, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalizedHistogram",2469,G__libBAT_rdict_453_0_55, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 2, 1, 1, 8, 
"u 'string' - 11 - name1 u 'string' - 11 - name2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalizedHistogram",2469,G__libBAT_rdict_453_0_56, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalized",1527,G__libBAT_rdict_453_0_57, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalized",1527,G__libBAT_rdict_453_0_58, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalized",1527,G__libBAT_rdict_453_0_59, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 2, 1, 1, 8, 
"u 'string' - 11 - name1 u 'string' - 11 - name2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalized",1527,G__libBAT_rdict_453_0_60, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximumParameterNameLength",2946,G__libBAT_rdict_453_0_61, 104, -1, -1, 0, 1, 1, 1, 8, "g - - 0 'true' observables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariable",1094,G__libBAT_rdict_453_0_62, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariable",1094,G__libBAT_rdict_453_0_63, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariable), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVariables",1287,G__libBAT_rdict_453_0_64, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameters",1332,G__libBAT_rdict_453_0_65, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameters",1332,G__libBAT_rdict_453_0_66, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameterSet), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameter",1217,G__libBAT_rdict_453_0_67, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameter",1217,G__libBAT_rdict_453_0_68, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameter",1217,G__libBAT_rdict_453_0_69, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParameter",1217,G__libBAT_rdict_453_0_70, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCParameter), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNParameters",1410,G__libBAT_rdict_453_0_71, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNFixedParameters",1906,G__libBAT_rdict_453_0_72, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNFreeParameters",1796,G__libBAT_rdict_453_0_73, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservables",1432,G__libBAT_rdict_453_0_74, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR), G__defined_typename("BCObservableSet"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservables",1432,G__libBAT_rdict_453_0_75, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR), G__defined_typename("BCObservableSet"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservable",1317,G__libBAT_rdict_453_0_76, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservable",1317,G__libBAT_rdict_453_0_77, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservable",1317,G__libBAT_rdict_453_0_78, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObservable",1317,G__libBAT_rdict_453_0_79, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCObservable), -1, 1, 1, 1, 1, 9, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNObservables",1510,G__libBAT_rdict_453_0_80, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,G__libBAT_rdict_453_0_81, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBestFitParameterErrors",2543,G__libBAT_rdict_453_0_82, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLocalModes",1283,G__libBAT_rdict_453_0_83, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 1, 1, 1, 1, "g - - 0 'false' force_recalculation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogMaximum",1312,G__libBAT_rdict_453_0_84, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReuseObservables",1948,G__libBAT_rdict_453_0_85, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCH1DdrawingOptions",2106,G__libBAT_rdict_453_0_86, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCH2DdrawingOptions",2107,G__libBAT_rdict_453_0_87, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,G__libBAT_rdict_453_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleFactorLowerLimit",2427,G__libBAT_rdict_453_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleFactorUpperLimit",2430,G__libBAT_rdict_453_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialScaleFactors",2224,G__libBAT_rdict_453_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNChains",976,G__libBAT_rdict_453_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNLag",654,G__libBAT_rdict_453_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsPreRunMax",2334,G__libBAT_rdict_453_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsRun",1745,G__libBAT_rdict_453_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsPreRunMin",2332,G__libBAT_rdict_453_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsPreRunCheck",2518,G__libBAT_rdict_453_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreRunCheckClear",1869,G__libBAT_rdict_453_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimumEfficiency",2045,G__libBAT_rdict_453_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - efficiency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaximumEfficiency",2047,G__libBAT_rdict_453_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - efficiency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRandomSeed",1294,G__libBAT_rdict_453_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialPositions",1982,G__libBAT_rdict_453_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x0s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialPositions",1982,G__libBAT_rdict_453_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >' 'vector<std::vector<double> >' 11 - x0s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialPositionScheme",2464,G__libBAT_rdict_453_0_104, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCEngineMCMC::InitialPositionScheme' - 0 - scheme", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitialPositionAttemptLimit",3113,G__libBAT_rdict_453_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProposeMultivariate",2315,G__libBAT_rdict_453_0_106, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProposalFunctionDof",2267,G__libBAT_rdict_453_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1' dof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultivariateCovarianceUpdateLambda",3778,G__libBAT_rdict_453_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultivariateEpsilon",2301,G__libBAT_rdict_453_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - epsilon", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMultivariateScaleMultiplier",3122,G__libBAT_rdict_453_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlagFillHistograms",2126,G__libBAT_rdict_453_0_111, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlagFillHistograms",2126,G__libBAT_rdict_453_0_112, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 - flag_1d g - - 0 - flag_2d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramParPar",2215,G__libBAT_rdict_453_0_113, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramParPar",2215,G__libBAT_rdict_453_0_114, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - x u 'string' - 11 - y "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramParObs",2216,G__libBAT_rdict_453_0_115, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramParObs",2216,G__libBAT_rdict_453_0_116, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - x u 'string' - 11 - y "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramObsObs",2217,G__libBAT_rdict_453_0_117, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramObsObs",2217,G__libBAT_rdict_453_0_118, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - x u 'string' - 11 - y "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramObsPar",2216,G__libBAT_rdict_453_0_119, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogramObsPar",2216,G__libBAT_rdict_453_0_120, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - x u 'string' - 11 - y "
"g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFlagPreRun",1282,G__libBAT_rdict_453_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRValueParametersCriterion",2878,G__libBAT_rdict_453_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCorrectRValueForSamplingVariability",3887,G__libBAT_rdict_453_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_453_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCEngineMCMC::Precision' - 0 - precision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_453_0_125, 121, -1, -1, 0, 1, 1, 1, 0, "U 'BCEngineMCMC' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_453_0_126, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCEngineMCMC' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNbins",806,G__libBAT_rdict_453_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReuseObservables",1960,G__libBAT_rdict_453_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRescaleHistogramRangesAfterPreRun",3655,G__libBAT_rdict_453_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistogramRescalingPadding",2857,G__libBAT_rdict_453_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChain",1630,G__libBAT_rdict_453_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChainRun",1939,G__libBAT_rdict_453_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChainPreRun",2234,G__libBAT_rdict_453_0_133, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChain",1630,G__libBAT_rdict_453_0_134, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 - option "
"g - - 0 'true' flag_run g - - 0 'true' flag_prerun", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorConstant",1666,G__libBAT_rdict_453_0_135, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorConstant",1666,G__libBAT_rdict_453_0_136, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrior",824,G__libBAT_rdict_453_0_137, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - u 'TF1' - 1 - f "
"g - - 0 'true' logL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrior",824,G__libBAT_rdict_453_0_138, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - name u 'TF1' - 1 - f "
"g - - 0 'true' logL", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorDelta",1314,G__libBAT_rdict_453_0_139, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorDelta",1314,G__libBAT_rdict_453_0_140, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorGauss",1339,G__libBAT_rdict_453_0_141, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 - mean "
"d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorGauss",1339,G__libBAT_rdict_453_0_142, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - mean "
"d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorGauss",1339,G__libBAT_rdict_453_0_143, 121, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - - d - - 0 - mode "
"d - - 0 - sigma_below d - - 0 - sigma_above", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorGauss",1339,G__libBAT_rdict_453_0_144, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - mode "
"d - - 0 - sigma_below d - - 0 - sigma_above", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrior",824,G__libBAT_rdict_453_0_145, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - u 'TH1' - 1 - h "
"g - - 0 'false' interpolate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrior",824,G__libBAT_rdict_453_0_146, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - name u 'TH1' - 1 - h "
"g - - 0 'false' interpolate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPriorConstantAll",1947,G__libBAT_rdict_453_0_147, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarginalizedDistributions",3157,G__libBAT_rdict_453_0_148, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 - option "
"g - - 0 'false' closeExistingFile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_453_0_149, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintParameters",1569,G__libBAT_rdict_453_0_150, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - P 1 - 'void (*)(const std::string&) ' 0 'BCLog::OutSummary' output", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintAllMarginalized",2045,G__libBAT_rdict_453_0_151, 104, -1, -1, 0, 3, 1, 1, 8, 
"u 'string' - 11 - filename h - - 0 '1' - "
"h - - 0 '1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintParameterPlot",1869,G__libBAT_rdict_453_0_152, 104, -1, -1, 0, 5, 1, 1, 8, 
"u 'string' - 11 - filename i - - 0 '10' npar "
"d - - 0 '68e-2' interval_content u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>(0)' quantile_values "
"g - - 0 'true' rescale_ranges", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawParameterPlot",1742,G__libBAT_rdict_453_0_153, 103, -1, -1, 0, 5, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' - "
"d - - 0 '68e-2' interval_content u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>(0)' quantile_values "
"g - - 0 'true' rescale_ranges", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCorrelationMatrix",2308,G__libBAT_rdict_453_0_154, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 '\"matrix.pdf\"' filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCorrelationPlot",2094,G__libBAT_rdict_453_0_155, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'string' - 11 '\"correlation.pdf\"' filename g - - 0 'true' include_observables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintParameterLatex",1964,G__libBAT_rdict_453_0_156, 103, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateHistograms",1653,G__libBAT_rdict_453_0_157, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'false' rescale_ranges", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitializeMarkovChainTree",2549,G__libBAT_rdict_453_0_158, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'false' replacetree g - - 0 'false' replacefile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddParameter",1194,G__libBAT_rdict_453_0_159, 103, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - min "
"d - - 0 - max u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddParameter",1194,G__libBAT_rdict_453_0_160, 103, -1, -1, 0, 1, 1, 1, 0, "u 'BCParameter' - 1 - parameter", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObservable",1294,G__libBAT_rdict_453_0_161, 103, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - min "
"d - - 0 - max u 'string' - 11 '\"\"' latexname "
"u 'string' - 11 '\"\"' unitstring", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddObservable",1294,G__libBAT_rdict_453_0_162, 103, -1, -1, 0, 1, 1, 1, 0, "u 'BCObservable' - 1 - obs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateObservables",1967,G__libBAT_rdict_453_0_163, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvaluateObservables",1967,G__libBAT_rdict_453_0_164, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateObservables",2054,G__libBAT_rdict_453_0_165, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProposalFunction",1686,G__libBAT_rdict_453_0_166, 100, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalPointMetropolis",2728,G__libBAT_rdict_453_0_167, 103, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - u 'vector<double,allocator<double> >' 'vector<double>' 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposalPointMetropolis",2728,G__libBAT_rdict_453_0_168, 103, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewPointMetropolis",2178,G__libBAT_rdict_453_0_169, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewPointMetropolis",2178,G__libBAT_rdict_453_0_170, 103, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewPointMetropolis",2178,G__libBAT_rdict_453_0_171, 103, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptOrRejectPoint",1912,G__libBAT_rdict_453_0_172, 103, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InChainFillHistograms",2114,G__libBAT_rdict_453_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCEngineMCMC::ChainState' - 11 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InChainFillHistograms",2114,G__libBAT_rdict_453_0_174, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InChainFillTree",1457,G__libBAT_rdict_453_0_175, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'BCEngineMCMC::ChainState' - 11 - cs h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InChainFillTree",1457,G__libBAT_rdict_453_0_176, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogEval",682,G__libBAT_rdict_453_0_177, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Metropolis",1070,G__libBAT_rdict_453_0_178, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MetropolisPreRun",1674,G__libBAT_rdict_453_0_179, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RValue",591,G__libBAT_rdict_453_0_180, 100, -1, -1, 0, 4, 3, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - means u 'vector<double,allocator<double> >' 'vector<double>' 11 - variances "
"h - - 0 - - g - - 0 'true' correctForSamplingVariability", (char*)NULL, (void*) G__func2void( (double (*)(const vector<double>&, const vector<double>&, unsigned int, bool))(&BCEngineMCMC::RValue) ), 0);
   G__memfunc_setup("MCMCInitialize",1330,G__libBAT_rdict_453_0_181, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MCMCUserInitialize",1745,G__libBAT_rdict_453_0_182, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetResults",1269,G__libBAT_rdict_453_0_183, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MCMCUserIterationInterface",2559,G__libBAT_rdict_453_0_184, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MCMCCurrentPointInterface",2462,G__libBAT_rdict_453_0_185, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - point i - - 0 - ichain "
"g - - 0 - accepted", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadParametersFromTree",2232,G__libBAT_rdict_453_0_186, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - partree g - - 0 'true' loadObservables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMCMCParameters",1716,G__libBAT_rdict_453_0_187, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TTree' - 1 - partree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParameterTreeMatchesModel",2535,G__libBAT_rdict_453_0_188, 103, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - partree g - - 0 'true' checkObservables", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadMCMC",672,G__libBAT_rdict_453_0_189, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 0 '\"\"' mcmcTreeName "
"u 'string' - 0 '\"\"' parameterTreeName g - - 0 'true' loadObservables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMCMC",672,G__libBAT_rdict_453_0_190, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - mcmcTree U 'TTree' - 0 - parTree "
"g - - 0 'true' loadObservables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidMCMCTree",1184,G__libBAT_rdict_453_0_191, 103, -1, -1, 0, 2, 1, 1, 8, 
"U 'TTree' - 0 - tree g - - 0 'true' checkObservables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidParameterTree",1825,G__libBAT_rdict_453_0_192, 103, -1, -1, 0, 1, 1, 1, 8, "U 'TTree' - 0 - tree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseOutputFile",1543,G__libBAT_rdict_453_0_193, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remarginalize",1354,G__libBAT_rdict_453_0_194, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' autorange", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareToContinueMarginalization",3328,G__libBAT_rdict_453_0_195, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 '\"\"' mcmcTreeName "
"u 'string' - 11 '\"\"' parameterTreeName g - - 0 'true' loadObservables "
"g - - 0 'true' autorange", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateMultivariateProposalFunctionCovariances",4702,G__libBAT_rdict_453_0_196, 103, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateMultivariateProposalFunctionCovariances",4702,G__libBAT_rdict_453_0_197, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateCholeskyDecompositions",3232,G__libBAT_rdict_453_0_198, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateChainIndex",1598,G__libBAT_rdict_453_0_199, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - chain", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SyncThreadStorage",1738,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteMarginals",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneMarginals",1423,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'BCEngineMCMC' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFillHistogram",1633,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - - 0 - x i - - 0 - y "
"g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintModelSummary",1772,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintBestFitSummary",1964,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBestFitSummary",1727,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 2, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintMarginalizationSummary",2852,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateParameterTree",1940,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateFrequency",1557,(G__InterfaceMethod) NULL, 104, -1, -1, 0, 1, 1, 2, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCEngineMCMC", 1145, G__libBAT_rdict_453_0_210, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCModel(void) {
   /* BCModel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel));
   G__memfunc_setup("operator=",937,G__libBAT_rdict_457_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel), -1, 1, 1, 1, 1, 0, "u 'BCModel' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataSet",966,G__libBAT_rdict_457_0_5, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDataPoints",1381,G__libBAT_rdict_457_0_6, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDoF",615,G__libBAT_rdict_457_0_7, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPriorModel",1309,G__libBAT_rdict_457_0_8, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel), -1, 0, 2, 1, 1, 0, 
"g - - 0 'true' prepare g - - 0 'false' call_likelihood", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_457_0_9, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPrior",812,G__libBAT_rdict_457_0_10, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 0, 2, 1, 1, 0, 
"h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBCH1DPriorDrawingOptions",2598,G__libBAT_rdict_457_0_11, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCH2DPriorDrawingOptions",2599,G__libBAT_rdict_457_0_12, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCH1DPosteriorDrawingOptions",3041,G__libBAT_rdict_457_0_13, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH1D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCH2DPosteriorDrawingOptions",3042,G__libBAT_rdict_457_0_14, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCH2D), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawPriorFirst",1730,G__libBAT_rdict_457_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSet",978,G__libBAT_rdict_457_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'BCDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKnowledgeUpdateDrawingStyle",3084,G__libBAT_rdict_457_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCAux::BCKnowledgeUpdateDrawingStyle' - 0 'BCAux::kKnowledgeUpdateDefaultStyle' style", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawPriorFirst",1742,G__libBAT_rdict_457_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APrioriProbability",1847,G__libBAT_rdict_457_0_19, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogAPrioriProbability",2137,G__libBAT_rdict_457_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Likelihood",1028,G__libBAT_rdict_457_0_21, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogLikelihood",1318,G__libBAT_rdict_457_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - params", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProbabilityNN",1309,G__libBAT_rdict_457_0_23, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogProbabilityNN",1599,G__libBAT_rdict_457_0_24, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Probability",1153,G__libBAT_rdict_457_0_25, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogProbability",1443,G__libBAT_rdict_457_0_26, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SamplingFunction",1665,G__libBAT_rdict_457_0_27, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogEval",682,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitializeMarkovChainTree",2549,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - - 0 'false' replacetree g - - 0 'false' replacefile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HessianMatrixElement",2058,G__libBAT_rdict_457_0_31, 100, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintShortFitSummary",2094,G__libBAT_rdict_457_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintHessianMatrix",1869,G__libBAT_rdict_457_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintKnowledgeUpdatePlots",2594,G__libBAT_rdict_457_0_34, 104, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - filename h - - 0 '1' - "
"h - - 0 '1' - g - - 0 'false' call_likelihood", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCModel", 756, G__libBAT_rdict_457_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCIntegrate(void) {
   /* BCIntegrate */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate));
   G__memfunc_setup("operator=",937,G__libBAT_rdict_522_0_4, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegrate), -1, 1, 1, 1, 1, 0, "u 'BCIntegrate' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntegral",1110,G__libBAT_rdict_522_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptimizationMethod",2184,G__libBAT_rdict_522_0_6, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntegrationMethod",2053,G__libBAT_rdict_522_0_7, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarginalizationMethod",2474,G__libBAT_rdict_522_0_8, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSASchedule",1249,G__libBAT_rdict_522_0_9, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomVectorInParameterSpace",3128,G__libBAT_rdict_522_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomPoint",1419,G__libBAT_rdict_522_0_11, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsMin",1716,G__libBAT_rdict_522_0_12, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsMax",1718,G__libBAT_rdict_522_0_13, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterationsPrecisionCheck",2842,G__libBAT_rdict_522_0_14, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNIterations",1424,G__libBAT_rdict_522_0_15, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRelativePrecision",2056,G__libBAT_rdict_522_0_16, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAbsolutePrecision",2059,G__libBAT_rdict_522_0_17, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCubaIntegrationMethod",2432,G__libBAT_rdict_522_0_18, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCubaVegasOptions",1917,G__libBAT_rdict_522_0_19, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLVegas), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCubaSuaveOptions",1931,G__libBAT_rdict_522_0_20, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLSuave), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCubaDivonneOptions",2138,G__libBAT_rdict_522_0_21, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLDivonne), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCubaCuhreOptions",1918,G__libBAT_rdict_522_0_22, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCCubaOptionscLcLCuhre), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__libBAT_rdict_522_0_23, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 6, 1, 1, 0, 
"u 'vector<unsigned int,allocator<unsigned int> >' 'vector<unsigned>' 0 - indices h - - 1 - nIterations "
"d - - 1 - log_max_val u 'vector<double,allocator<double> >' 'vector<double>' 10 'std::vector<double>(0)' parameters "
"i - - 0 '0' nbins g - - 0 'true' normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__libBAT_rdict_522_0_24, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 6, 1, 1, 0, 
"u 'string' - 11 - name h - - 1 - nIterations "
"d - - 1 - log_max_val u 'vector<double,allocator<double> >' 'vector<double>' 10 'std::vector<double>(0)' parameters "
"i - - 0 '0' nbins g - - 0 'true' normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__libBAT_rdict_522_0_25, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH1), -1, 0, 6, 1, 1, 0, 
"h - - 0 - - h - - 1 - nIterations "
"d - - 1 - log_max_val u 'vector<double,allocator<double> >' 'vector<double>' 10 'std::vector<double>(0)' parameters "
"i - - 0 '0' nbins g - - 0 'true' normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__libBAT_rdict_522_0_26, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 7, 1, 1, 0, 
"u 'string' - 11 - name1 u 'string' - 11 - name2 "
"h - - 1 - nIterations d - - 1 - log_max_val "
"u 'vector<double,allocator<double> >' 'vector<double>' 10 'std::vector<double>(0)' parameters i - - 0 '0' nbins "
"g - - 0 'true' normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSlice",784,G__libBAT_rdict_522_0_27, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_TH2), -1, 0, 7, 1, 1, 0, 
"h - - 0 - - h - - 0 - - "
"h - - 1 - nIterations d - - 1 - log_max_val "
"u 'vector<double,allocator<double> >' 'vector<double>' 10 'std::vector<double>(0)' parameters i - - 0 '0' nbins "
"g - - 0 'true' normalize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__libBAT_rdict_522_0_28, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinuit",918,G__libBAT_rdict_522_0_29, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_TMinuitMinimizer), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSAT0",568,G__libBAT_rdict_522_0_30, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSATmin",844,G__libBAT_rdict_522_0_31, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBestFitParameters",2021,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBestFitParameterErrors",2543,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLogMaximum",1312,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFlagIgnorePrevOptimization",2990,G__libBAT_rdict_522_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptimizationMethod",2196,G__libBAT_rdict_522_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCOptimizationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIntegrationMethod",2065,G__libBAT_rdict_522_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCIntegrationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarginalizationMethod",2486,G__libBAT_rdict_522_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCMarginalizationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSASchedule",1261,G__libBAT_rdict_522_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCSASchedule' - 0 - schedule", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsMin",1728,G__libBAT_rdict_522_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsMax",1730,G__libBAT_rdict_522_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsPrecisionCheck",2854,G__libBAT_rdict_522_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRelativePrecision",2068,G__libBAT_rdict_522_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - relprecision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAbsolutePrecision",2071,G__libBAT_rdict_522_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - absprecision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCubaIntegrationMethod",2444,G__libBAT_rdict_522_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCCubaMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCubaOptions",1427,G__libBAT_rdict_522_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCCubaOptions::Vegas' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCubaOptions",1427,G__libBAT_rdict_522_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCCubaOptions::Suave' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCubaOptions",1427,G__libBAT_rdict_522_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCCubaOptions::Divonne' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCubaOptions",1427,G__libBAT_rdict_522_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'BCCubaOptions::Cuhre' - 11 - options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSAT0",580,G__libBAT_rdict_522_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - T0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSATmin",856,G__libBAT_rdict_522_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - Tmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,G__libBAT_rdict_522_0_52, 100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LogEval",682,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Normalize",945,G__libBAT_rdict_522_0_54, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integrate",931,G__libBAT_rdict_522_0_55, 100, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCIntegrationMethod' - 0 - intmethod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integrate",931,G__libBAT_rdict_522_0_56, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integrate",931,G__libBAT_rdict_522_0_57, 100, -1, -1, 0, 5, 1, 1, 0, 
"i 'BCIntegrate::BCIntegrationMethod' - 0 - type a - 'BCIntegrate::tRandomizer' 0 - randomizer "
"a - 'BCIntegrate::tEvaluator' 0 - evaluator Y - 'BCIntegrate::tIntegralUpdater' 0 - updater "
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - sums", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluatorMC",1091,G__libBAT_rdict_522_0_58, 100, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - sums u 'vector<double,allocator<double> >' 'vector<double>' 11 - point "
"g - - 1 - accepted", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegralUpdaterMC",1691,G__libBAT_rdict_522_0_59, 121, -1, -1, 0, 4, 3, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - sums i - - 11 - nIterations "
"d - - 1 - integral d - - 1 - absprecision", (char*)NULL, (void*) G__func2void( (void (*)(const vector<double>&, const int&, double&, double&))(&BCIntegrate::IntegralUpdaterMC) ), 0);
   G__memfunc_setup("MarginalizeAll",1420,G__libBAT_rdict_522_0_60, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarginalizeAll",1420,G__libBAT_rdict_522_0_61, 105, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCMarginalizationMethod' - 0 - margmethod", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarginalizePreprocess",2201,G__libBAT_rdict_522_0_62, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MarginalizePostprocess",2328,G__libBAT_rdict_522_0_63, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindMode",774,G__libBAT_rdict_522_0_64, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>()' start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMode",774,G__libBAT_rdict_522_0_65, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 0, 
"i 'BCIntegrate::BCOptimizationMethod' - 0 - optmethod u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>()' start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SATemperature",1314,G__libBAT_rdict_522_0_66, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SATemperatureBoltzmann",2263,G__libBAT_rdict_522_0_67, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SATemperatureCauchy",1919,G__libBAT_rdict_522_0_68, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SATemperatureCustom",1949,G__libBAT_rdict_522_0_69, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProposalPointSA",1806,G__libBAT_rdict_522_0_70, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - x i - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposalPointSABoltzmann",2755,G__libBAT_rdict_522_0_71, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - x i - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposalPointSACauchy",2411,G__libBAT_rdict_522_0_72, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - x i - - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProposalPointSACustom",2441,G__libBAT_rdict_522_0_73, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 1, 8, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - x i - - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SAHelperGetRandomPointOnHypersphere",3531,G__libBAT_rdict_522_0_74, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SAHelperGetRadialCauchy",2238,G__libBAT_rdict_522_0_75, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SAHelperSinusToNIntegral",2381,G__libBAT_rdict_522_0_76, 100, -1, -1, 0, 2, 1, 1, 8, 
"i - - 0 - dim d - - 0 - theta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetResults",1269,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DumpIntegrationMethod",2171,G__libBAT_rdict_522_0_78, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 8, "i 'BCIntegrate::BCIntegrationMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCurrentIntegrationMethod",2910,G__libBAT_rdict_522_0_79, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpUsedIntegrationMethod",2572,G__libBAT_rdict_522_0_80, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpMarginalizationMethod",2592,G__libBAT_rdict_522_0_81, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 8, "i 'BCIntegrate::BCMarginalizationMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCurrentMarginalizationMethod",3331,G__libBAT_rdict_522_0_82, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpUsedMarginalizationMethod",2993,G__libBAT_rdict_522_0_83, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpOptimizationMethod",2302,G__libBAT_rdict_522_0_84, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 8, "i 'BCIntegrate::BCOptimizationMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCurrentOptimizationMethod",3041,G__libBAT_rdict_522_0_85, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpUsedOptimizationMethod",2703,G__libBAT_rdict_522_0_86, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCubaIntegrationMethod",2550,G__libBAT_rdict_522_0_87, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 1, 8, "i 'BCIntegrate::BCCubaMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpCubaIntegrationMethod",2550,G__libBAT_rdict_522_0_88, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBestFitParameters",2033,G__libBAT_rdict_522_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBestFitParameters",2033,G__libBAT_rdict_522_0_90, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - x d - - 11 - new_value "
"d - - 1 - old_value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckMarginalizationAvailability",3298,G__libBAT_rdict_522_0_91, 103, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCMarginalizationMethod' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckMarginalizationIndices",2758,G__libBAT_rdict_522_0_92, 103, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - hist u 'vector<unsigned int,allocator<unsigned int> >' 'vector<unsigned>' 11 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegrateLaplace",1621,G__libBAT_rdict_522_0_93, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegrationOutputFrequency",2759,(G__InterfaceMethod) NULL, 104, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintBestFitSummary",1964,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBestFitSummary",1727,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_string), -1, 0, 1, 1, 2, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintMarginalizationSummary",2852,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogOutputAtStartOfIntegration",2991,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i 'BCIntegrate::BCIntegrationMethod' - 0 - type i 'BCIntegrate::BCCubaMethod' - 0 - cubatype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogOutputAtIntegrationStatusUpdate",3539,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"i 'BCIntegrate::BCIntegrationMethod' - 0 - type d - - 0 - integral "
"d - - 0 - absprecision i - - 0 - nIterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogOutputAtEndOfIntegration",2744,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"d - - 0 - integral d - - 0 - absprecision "
"d - - 0 - relprecision i - - 0 - nIterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindModeMinuit",1404,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 4, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - mode u 'vector<double,allocator<double> >' 'vector<double>' 1 - errors "
"u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>(0)' start i - - 0 '-1' printlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindModeMCMC",1062,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 2, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - mode u 'vector<double,allocator<double> >' 'vector<double>' 1 - errors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindModeSA",922,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 3, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 1 - mode u 'vector<double,allocator<double> >' 'vector<double>' 1 - errors "
"u 'vector<double,allocator<double> >' 'vector<double>' 0 'std::vector<double>(0)' start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegrateCuba",1310,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegrateCuba",1310,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 0, "i 'BCIntegrate::BCCubaMethod' - 0 - cubatype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CubaIntegrand",1303,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 5, 3, 4, 0, 
"I - - 10 - ndim D - - 10 - xx "
"I - - 10 - ncomp D - - 0 - ff "
"Y - - 0 - userdata", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntegrateSlice",1427,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCIntegrate", 1190, G__libBAT_rdict_522_0_108, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCPriorModel(void) {
   /* BCPriorModel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel));
   G__memfunc_setup("BCPriorModel",1154,G__libBAT_rdict_537_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCPriorModel), -1, 0, 2, 1, 1, 0, 
"u 'BCModel' - 1 - model g - - 0 'false' call_likelihood", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogAPrioriProbability",2137,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LogLikelihood",1318,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateObservables",2054,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - parameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreparePriorModel",1740,G__libBAT_rdict_537_0_5, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCallLikelihood",1708,G__libBAT_rdict_537_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCallLikelihood",1696,G__libBAT_rdict_537_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCPriorModel", 1280, G__libBAT_rdict_537_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCEmptyModel(void) {
   /* BCEmptyModel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel));
   G__memfunc_setup("BCEmptyModel",1157,G__libBAT_rdict_538_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel), -1, 0, 1, 1, 1, 0, "u 'string' - 11 '\"model\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCEmptyModel",1157,G__libBAT_rdict_538_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCEmptyModel), -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - filename u 'string' - 11 - name "
"g - - 0 'true' loadObservables", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogLikelihood",1318,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~BCEmptyModel", 1283, G__libBAT_rdict_538_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncBCModelManager(void) {
   /* BCModelManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__libBAT_rdictLN_BCModelManager));
   G__memfunc_setup("BCModelManager",1329,G__libBAT_rdict_539_0_1, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCModelManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BCModelManager",1329,G__libBAT_rdict_539_0_2, 105, G__get_linked_tagnum(&G__libBAT_rdictLN_BCModelManager), -1, 0, 1, 1, 1, 0, "u 'BCModelManager' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__libBAT_rdict_539_0_3, 117, G__get_linked_tagnum(&G__libBAT_rdictLN_BCModelManager), -1, 1, 1, 1, 1, 0, "u 'BCModelManager' - 0 - modelmanager", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNModels",978,G__libBAT_rdict_539_0_4, 104, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetModel",785,G__libBAT_rdict_539_0_5, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCModel), -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataSet",966,G__libBAT_rdict_539_0_6, 85, G__get_linked_tagnum(&G__libBAT_rdictLN_BCDataSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSet",978,G__libBAT_rdict_539_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'BCDataSet' - 0 - dataset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__libBAT_rdict_539_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCEngineMCMC::Precision' - 0 - precision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsMax",1730,G__libBAT_rdict_539_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsMin",1728,G__libBAT_rdict_539_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNIterationsPrecisionCheck",2854,G__libBAT_rdict_539_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - niterations", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarginalizationMethod",2486,G__libBAT_rdict_539_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCMarginalizationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIntegrationMethod",2065,G__libBAT_rdict_539_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCIntegrationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptimizationMethod",2196,G__libBAT_rdict_539_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i 'BCIntegrate::BCOptimizationMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRelativePrecision",2068,G__libBAT_rdict_539_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - relprecision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAbsolutePrecision",2071,G__libBAT_rdict_539_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - absprecision", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNbins",806,G__libBAT_rdict_539_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNChains",976,G__libBAT_rdict_539_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddModel",762,G__libBAT_rdict_539_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'BCModel' - 0 - model d - - 0 '0.' prior_probability", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Integrate",931,G__libBAT_rdict_539_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BayesFactor",1107,G__libBAT_rdict_539_0_21, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 10 - imodel1 h - - 10 - imodel2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMode",774,G__libBAT_rdict_539_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MarginalizeAll",1420,G__libBAT_rdict_539_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChain",1630,G__libBAT_rdict_539_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChainRun",1939,G__libBAT_rdict_539_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChainPreRun",2234,G__libBAT_rdict_539_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMarkovChain",1630,G__libBAT_rdict_539_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'string' - 11 - prefix u 'string' - 11 - option "
"g - - 0 'true' flag_run g - - 0 'true' flag_prerun", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintModelComparisonSummary",2823,G__libBAT_rdict_539_0_28, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintSummary",1275,G__libBAT_rdict_539_0_29, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BCModelManager", 1455, G__libBAT_rdict_539_0_30, (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_memfunclibBAT_rdict() {
}

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

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

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

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

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

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {
}

static void G__cpp_setup_func28() {
}

static void G__cpp_setup_func29() {
}

static void G__cpp_setup_func30() {
}

static void G__cpp_setup_func31() {
}

static void G__cpp_setup_func32() {
}

static void G__cpp_setup_func33() {
}

static void G__cpp_setup_func34() {
}

static void G__cpp_setup_func35() {
}

static void G__cpp_setup_func36() {
}

static void G__cpp_setup_func37() {
}

static void G__cpp_setup_func38() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funclibBAT_rdict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
  G__cpp_setup_func28();
  G__cpp_setup_func29();
  G__cpp_setup_func30();
  G__cpp_setup_func31();
  G__cpp_setup_func32();
  G__cpp_setup_func33();
  G__cpp_setup_func34();
  G__cpp_setup_func35();
  G__cpp_setup_func36();
  G__cpp_setup_func37();
  G__cpp_setup_func38();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__libBAT_rdictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_string = { "string" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TLegendEntry = { "TLegendEntry" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TLegend = { "TLegend" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCHistogramBase = { "BCHistogramBase" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme = { "BCHistogramBase::BCHColorScheme" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR = { "vector<TObject*,allocator<TObject*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETObjectmUcOallocatorlETObjectmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TObject*,allocator<TObject*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR = { "vector<TLegendEntry*,allocator<TLegendEntry*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TLegendEntry*,allocator<TLegendEntry*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCLog = { "BCLog" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCLogcLcLLogLevel = { "BCLog::LogLevel" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCMath = { "BCMath" , 110 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TH3 = { "TH3" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCVariable = { "BCVariable" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCDataPoint = { "BCDataPoint" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TGraphErrors = { "TGraphErrors" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TGraphAsymmErrors = { "TGraphAsymmErrors" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCDataSet = { "BCDataSet" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR = { "vector<BCDataPoint,allocator<BCDataPoint> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCDataPointcOallocatorlEBCDataPointgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCDataPoint,allocator<BCDataPoint> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH1D = { "BCH1D" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType = { "BCH1D::BCH1DBandType" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH1DcLcLBCH1DSmallestInterval = { "BCH1D::BCH1DSmallestInterval" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR = { "vector<BCH1D::BCH1DInterval,allocator<BCH1D::BCH1DInterval> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCH1D::BCH1DInterval,allocator<BCH1D::BCH1DInterval> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR = { "vector<BCH1D::BCH1DSmallestInterval,allocator<BCH1D::BCH1DSmallestInterval> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCH1D::BCH1DSmallestInterval,allocator<BCH1D::BCH1DSmallestInterval> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH2D = { "BCH2D" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType = { "BCH2D::BCH2DBandType" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType = { "BCH2D::BCH2DProfileType" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileAxis = { "BCH2D::BCH2DProfileAxis" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCPrior = { "BCPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCParameter = { "BCParameter" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCAux = { "BCAux" , 110 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCAuxcLcLBCRange = { "BCAux::BCRange" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle = { "BCAux::BCKnowledgeUpdateDrawingStyle" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCAuxcLcLBCTrashlETObjectgR = { "BCAux::BCTrash<TObject>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR = { "vector<BCH1D,allocator<BCH1D> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcOallocatorlEBCH1DgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCH1D,allocator<BCH1D> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR = { "vector<BCH2D,allocator<BCH2D> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH2DcOallocatorlEBCH2DgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCH2D,allocator<BCH2D> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCConstantPrior = { "BCConstantPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCGaussianPrior = { "BCGaussianPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCSplitGaussianPrior = { "BCSplitGaussianPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCauchyPrior = { "BCCauchyPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCObservable = { "BCObservable" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCVariableSetlEBCObservablegR = { "BCVariableSet<BCObservable>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR = { "vector<BCObservable,allocator<BCObservable> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCObservablecOallocatorlEBCObservablegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCObservable,allocator<BCObservable> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCTF1Prior = { "BCTF1Prior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCTF1LogPrior = { "BCTF1LogPrior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCTH1Prior = { "BCTH1Prior" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCParameterSet = { "BCParameterSet" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCVariableSetlEBCParametergR = { "BCVariableSet<BCParameter>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR = { "vector<BCParameter,allocator<BCParameter> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCParametercOallocatorlEBCParametergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCParameter,allocator<BCParameter> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMC = { "BCEngineMCMC" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision = { "BCEngineMCMC::Precision" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMCcLcLPhase = { "BCEngineMCMC::Phase" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme = { "BCEngineMCMC::InitialPositionScheme" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCModel = { "BCModel" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMCcLcLChainState = { "BCEngineMCMC::ChainState" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics = { "BCEngineMCMC::Statistics" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR = { "vector<BCEngineMCMC::Statistics,allocator<BCEngineMCMC::Statistics> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCEngineMCMC::Statistics,allocator<BCEngineMCMC::Statistics> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_pairlEunsignedsPintcOunsignedsPintgR = { "pair<unsigned int,unsigned int>" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR = { "vector<pair<unsigned int,unsigned int>,allocator<pair<unsigned int,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,unsigned int>,allocator<pair<unsigned int,unsigned int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR = { "vector<BCEngineMCMC::ThreadLocalStorage,allocator<BCEngineMCMC::ThreadLocalStorage> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCEngineMCMC::ThreadLocalStorage,allocator<BCEngineMCMC::ThreadLocalStorage> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR = { "vector<TMatrixTSym<double>,allocator<TMatrixTSym<double> > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixTSym<double>,allocator<TMatrixTSym<double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR = { "vector<TMatrixT<double>,allocator<TMatrixT<double> > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixT<double>,allocator<TMatrixT<double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR = { "vector<BCEngineMCMC::ChainState,allocator<BCEngineMCMC::ChainState> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCEngineMCMC::ChainState,allocator<BCEngineMCMC::ChainState> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR = { "vector<TH1*,allocator<TH1*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1*,allocator<TH1*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR = { "vector<TH2*,allocator<TH2*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH2*,allocator<TH2*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR = { "vector<vector<TH2*,allocator<TH2*> >,allocator<vector<TH2*,allocator<TH2*> > > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TH2*,allocator<TH2*> >,allocator<vector<TH2*,allocator<TH2*> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR = { "vector<pair<int,int>,allocator<pair<int,int> > >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<int,int>,allocator<pair<int,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_TMinuitMinimizer = { "TMinuitMinimizer" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegrate = { "BCIntegrate" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCubaOptions = { "BCCubaOptions" , 110 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCubaOptionscLcLVegas = { "BCCubaOptions::Vegas" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCubaOptionscLcLSuave = { "BCCubaOptions::Suave" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCubaOptionscLcLDivonne = { "BCCubaOptions::Divonne" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCCubaOptionscLcLCuhre = { "BCCubaOptions::Cuhre" , 115 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCMinimizer = { "BCMinimizer" , 110 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCMinimizercLcLWrapper = { "BCMinimizer::Wrapper" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod = { "BCIntegrate::BCOptimizationMethod" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod = { "BCIntegrate::BCIntegrationMethod" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod = { "BCIntegrate::BCMarginalizationMethod" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule = { "BCIntegrate::BCSASchedule" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod = { "BCIntegrate::BCCubaMethod" , 101 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCPriorModel = { "BCPriorModel" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCEmptyModel = { "BCEmptyModel" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_BCModelManager = { "BCModelManager" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR = { "vector<BCModel*,allocator<BCModel*> >" , 99 , -1 };
G__linked_taginfo G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCModelmUcOallocatorlEBCModelmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<BCModel*,allocator<BCModel*> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtablelibBAT_rdict() {
  G__libBAT_rdictLN_TObject.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_string.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_TLegendEntry.tagnum = -1 ;
  G__libBAT_rdictLN_TLegend.tagnum = -1 ;
  G__libBAT_rdictLN_TH1.tagnum = -1 ;
  G__libBAT_rdictLN_BCHistogramBase.tagnum = -1 ;
  G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETObjectmUcOallocatorlETObjectmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_BCLog.tagnum = -1 ;
  G__libBAT_rdictLN_BCLogcLcLLogLevel.tagnum = -1 ;
  G__libBAT_rdictLN_TRandom.tagnum = -1 ;
  G__libBAT_rdictLN_BCMath.tagnum = -1 ;
  G__libBAT_rdictLN_TH2.tagnum = -1 ;
  G__libBAT_rdictLN_TH3.tagnum = -1 ;
  G__libBAT_rdictLN_BCVariable.tagnum = -1 ;
  G__libBAT_rdictLN_BCDataPoint.tagnum = -1 ;
  G__libBAT_rdictLN_TGraph.tagnum = -1 ;
  G__libBAT_rdictLN_TGraphErrors.tagnum = -1 ;
  G__libBAT_rdictLN_TGraphAsymmErrors.tagnum = -1 ;
  G__libBAT_rdictLN_BCDataSet.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCDataPointcOallocatorlEBCDataPointgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_BCH1D.tagnum = -1 ;
  G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType.tagnum = -1 ;
  G__libBAT_rdictLN_BCH1DcLcLBCH1DSmallestInterval.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_BCH2D.tagnum = -1 ;
  G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType.tagnum = -1 ;
  G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType.tagnum = -1 ;
  G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileAxis.tagnum = -1 ;
  G__libBAT_rdictLN_BCPrior.tagnum = -1 ;
  G__libBAT_rdictLN_BCParameter.tagnum = -1 ;
  G__libBAT_rdictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__libBAT_rdictLN_TFile.tagnum = -1 ;
  G__libBAT_rdictLN_BCAux.tagnum = -1 ;
  G__libBAT_rdictLN_BCAuxcLcLBCRange.tagnum = -1 ;
  G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle.tagnum = -1 ;
  G__libBAT_rdictLN_BCAuxcLcLBCTrashlETObjectgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcOallocatorlEBCH1DgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH2DcOallocatorlEBCH2DgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_TF1.tagnum = -1 ;
  G__libBAT_rdictLN_BCConstantPrior.tagnum = -1 ;
  G__libBAT_rdictLN_BCGaussianPrior.tagnum = -1 ;
  G__libBAT_rdictLN_BCSplitGaussianPrior.tagnum = -1 ;
  G__libBAT_rdictLN_BCCauchyPrior.tagnum = -1 ;
  G__libBAT_rdictLN_BCObservable.tagnum = -1 ;
  G__libBAT_rdictLN_BCVariableSetlEBCObservablegR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCObservablecOallocatorlEBCObservablegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_BCTF1Prior.tagnum = -1 ;
  G__libBAT_rdictLN_BCTF1LogPrior.tagnum = -1 ;
  G__libBAT_rdictLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__libBAT_rdictLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_BCTH1Prior.tagnum = -1 ;
  G__libBAT_rdictLN_BCParameterSet.tagnum = -1 ;
  G__libBAT_rdictLN_BCVariableSetlEBCParametergR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCParametercOallocatorlEBCParametergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__libBAT_rdictLN_TRandom3.tagnum = -1 ;
  G__libBAT_rdictLN_TTree.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMC.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMCcLcLPhase.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme.tagnum = -1 ;
  G__libBAT_rdictLN_BCModel.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMCcLcLChainState.tagnum = -1 ;
  G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_pairlEunsignedsPintcOunsignedsPintgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__libBAT_rdictLN_TMinuitMinimizer.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegrate.tagnum = -1 ;
  G__libBAT_rdictLN_BCCubaOptions.tagnum = -1 ;
  G__libBAT_rdictLN_BCCubaOptionscLcLVegas.tagnum = -1 ;
  G__libBAT_rdictLN_BCCubaOptionscLcLSuave.tagnum = -1 ;
  G__libBAT_rdictLN_BCCubaOptionscLcLDivonne.tagnum = -1 ;
  G__libBAT_rdictLN_BCCubaOptionscLcLCuhre.tagnum = -1 ;
  G__libBAT_rdictLN_BCMinimizer.tagnum = -1 ;
  G__libBAT_rdictLN_BCMinimizercLcLWrapper.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule.tagnum = -1 ;
  G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod.tagnum = -1 ;
  G__libBAT_rdictLN_BCPriorModel.tagnum = -1 ;
  G__libBAT_rdictLN_BCEmptyModel.tagnum = -1 ;
  G__libBAT_rdictLN_BCModelManager.tagnum = -1 ;
  G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR.tagnum = -1 ;
  G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCModelmUcOallocatorlEBCModelmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtablelibBAT_rdict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TObject);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_string);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TLegendEntry);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TLegend);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TH1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCHistogramBase),sizeof(BCHistogramBase),-1,69376,(char*)NULL,G__setup_memvarBCHistogramBase,G__setup_memfuncBCHistogramBase);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCHistogramBasecLcLBCHColorScheme);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETObjectmUcOallocatorlETObjectmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETObjectmUcOallocatorlETObjectmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETLegendEntrymUcOallocatorlETLegendEntrymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCLog),sizeof(BCLog),-1,65792,(char*)NULL,G__setup_memvarBCLog,G__setup_memfuncBCLog);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCLogcLcLLogLevel);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TRandom);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCMath),0,-1,65536,(char*)NULL,G__setup_memvarBCMath,G__setup_memfuncBCMath);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TH2);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TH3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCVariable),sizeof(BCVariable),-1,99584,(char*)NULL,G__setup_memvarBCVariable,G__setup_memfuncBCVariable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCDataPoint),sizeof(BCDataPoint),-1,98560,(char*)NULL,G__setup_memvarBCDataPoint,G__setup_memfuncBCDataPoint);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TGraph);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TGraphErrors);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TGraphAsymmErrors);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCDataSet),sizeof(BCDataSet),-1,66816,(char*)NULL,G__setup_memvarBCDataSet,G__setup_memfuncBCDataSet);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCDataPointcOallocatorlEBCDataPointgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCDataPointcOallocatorlEBCDataPointgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH1D),sizeof(BCH1D),-1,67328,(char*)NULL,G__setup_memvarBCH1D,G__setup_memfuncBCH1D);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH1DcLcLBCH1DBandType);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH1DcLcLBCH1DSmallestInterval);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DIntervalcOallocatorlEBCH1DcLcLBCH1DIntervalgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcLcLBCH1DSmallestIntervalcOallocatorlEBCH1DcLcLBCH1DSmallestIntervalgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH2D),sizeof(BCH2D),-1,67328,(char*)NULL,G__setup_memvarBCH2D,G__setup_memfuncBCH2D);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH2DcLcLBCH2DBandType);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileType);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCH2DcLcLBCH2DProfileAxis);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCPrior),sizeof(BCPrior),-1,67331,(char*)NULL,G__setup_memvarBCPrior,G__setup_memfuncBCPrior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCParameter),sizeof(BCParameter),-1,102144,(char*)NULL,G__setup_memvarBCParameter,G__setup_memfuncBCParameter);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TFile);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCAux),0,-1,65536,(char*)NULL,G__setup_memvarBCAux,G__setup_memfuncBCAux);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCAuxcLcLBCRange);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCAuxcLcLBCKnowledgeUpdateDrawingStyle);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCAuxcLcLBCTrashlETObjectgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCH1DcOallocatorlEBCH1DgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH1DcOallocatorlEBCH1DgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCH2DcOallocatorlEBCH2DgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCH2DcOallocatorlEBCH2DgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TF1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCConstantPrior),sizeof(BCConstantPrior),-1,99584,(char*)NULL,G__setup_memvarBCConstantPrior,G__setup_memfuncBCConstantPrior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCGaussianPrior),sizeof(BCGaussianPrior),-1,99328,(char*)NULL,G__setup_memvarBCGaussianPrior,G__setup_memfuncBCGaussianPrior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCSplitGaussianPrior),sizeof(BCSplitGaussianPrior),-1,99840,(char*)NULL,G__setup_memvarBCSplitGaussianPrior,G__setup_memfuncBCSplitGaussianPrior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCauchyPrior),sizeof(BCCauchyPrior),-1,99328,(char*)NULL,G__setup_memvarBCCauchyPrior,G__setup_memfuncBCCauchyPrior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCObservable),sizeof(BCObservable),-1,100608,(char*)NULL,G__setup_memvarBCObservable,G__setup_memfuncBCObservable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCVariableSetlEBCObservablegR),sizeof(BCVariableSet<BCObservable>),-1,66816,(char*)NULL,G__setup_memvarBCVariableSetlEBCObservablegR,G__setup_memfuncBCVariableSetlEBCObservablegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCObservablecOallocatorlEBCObservablegRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCObservablecOallocatorlEBCObservablegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCTF1Prior),sizeof(BCTF1Prior),-1,99328,(char*)NULL,G__setup_memvarBCTF1Prior,G__setup_memfuncBCTF1Prior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCTF1LogPrior),sizeof(BCTF1LogPrior),-1,99328,(char*)NULL,G__setup_memvarBCTF1LogPrior,G__setup_memfuncBCTF1LogPrior);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TVectorTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCTH1Prior),sizeof(BCTH1Prior),-1,101888,(char*)NULL,G__setup_memvarBCTH1Prior,G__setup_memfuncBCTH1Prior);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCParameterSet),sizeof(BCParameterSet),-1,66816,(char*)NULL,G__setup_memvarBCParameterSet,G__setup_memfuncBCParameterSet);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCVariableSetlEBCParametergR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCParametercOallocatorlEBCParametergRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCParametercOallocatorlEBCParametergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TRandom3);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMC),sizeof(BCEngineMCMC),-1,102145,(char*)NULL,G__setup_memvarBCEngineMCMC,G__setup_memfuncBCEngineMCMC);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMCcLcLPrecision);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMCcLcLPhase);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMCcLcLInitialPositionScheme);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCModel),sizeof(BCModel),-1,102145,(char*)NULL,G__setup_memvarBCModel,G__setup_memfuncBCModel);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMCcLcLChainState);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEngineMCMCcLcLStatistics);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLStatisticscOallocatorlEBCEngineMCMCcLcLStatisticsgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_pairlEunsignedsPintcOunsignedsPintgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOunsignedsPintgRcOallocatorlEpairlEunsignedsPintcOunsignedsPintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLThreadLocalStoragecOallocatorlEBCEngineMCMCcLcLThreadLocalStoragegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRcOallocatorlETMatrixTSymlEdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETMatrixTlEdoublegRcOallocatorlETMatrixTlEdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCEngineMCMCcLcLChainStatecOallocatorlEBCEngineMCMCcLcLChainStategRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETH1mUcOallocatorlETH1mUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlETH2mUcOallocatorlETH2mUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRcOallocatorlEvectorlETH2mUcOallocatorlETH2mUgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEpairlEintcOintgRcOallocatorlEpairlEintcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_TMinuitMinimizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegrate),sizeof(BCIntegrate),-1,102145,(char*)NULL,G__setup_memvarBCIntegrate,G__setup_memfuncBCIntegrate);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCubaOptions);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCubaOptionscLcLVegas);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCubaOptionscLcLSuave);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCubaOptionscLcLDivonne);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCCubaOptionscLcLCuhre);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCMinimizer);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCMinimizercLcLWrapper);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegratecLcLBCOptimizationMethod);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegratecLcLBCIntegrationMethod);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegratecLcLBCMarginalizationMethod);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegratecLcLBCSASchedule);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCIntegratecLcLBCCubaMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCPriorModel),sizeof(BCPriorModel),-1,98304,(char*)NULL,G__setup_memvarBCPriorModel,G__setup_memfuncBCPriorModel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCEmptyModel),sizeof(BCEmptyModel),-1,99584,(char*)NULL,G__setup_memvarBCEmptyModel,G__setup_memfuncBCEmptyModel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_BCModelManager),sizeof(BCModelManager),-1,69376,(char*)NULL,G__setup_memvarBCModelManager,G__setup_memfuncBCModelManager);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_vectorlEBCModelmUcOallocatorlEBCModelmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__libBAT_rdictLN_reverse_iteratorlEvectorlEBCModelmUcOallocatorlEBCModelmUgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setuplibBAT_rdict(void) {
  G__check_setup_version(30051515,"G__cpp_setuplibBAT_rdict()");
  G__set_cpp_environmentlibBAT_rdict();
  G__cpp_setup_tagtablelibBAT_rdict();

  G__cpp_setup_inheritancelibBAT_rdict();

  G__cpp_setup_typetablelibBAT_rdict();

  G__cpp_setup_memvarlibBAT_rdict();

  G__cpp_setup_memfunclibBAT_rdict();
  G__cpp_setup_globallibBAT_rdict();
  G__cpp_setup_funclibBAT_rdict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfunclibBAT_rdict();
  return;
}
class G__cpp_setup_initlibBAT_rdict {
  public:
    G__cpp_setup_initlibBAT_rdict() { G__add_setup_func("libBAT_rdict",(G__incsetup)(&G__cpp_setuplibBAT_rdict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initlibBAT_rdict() { G__remove_setup_func("libBAT_rdict"); }
};
G__cpp_setup_initlibBAT_rdict G__cpp_setup_initializerlibBAT_rdict;